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

With no annotations, the description must reveal behavior on its own. It conveys that the operation is a read and includes billing/shipping/credit details, but it does not mention the select parameter's effect, payload size, access permissions, or error behavior. It adds some value but is not fully 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, well-structured sentence that immediately states the action and target, with no filler or redundant information. It earns its place entirely.

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

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

For a low-complexity tool with only two parameters and no output schema, the description adequately conveys the core purpose and the kind of information returned. It could mention how the select parameter shapes the response or specify error behavior, but these are optional for a simple get-by-ID operation.

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

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

The input schema already documents both parameters fully (e.g., customerID example and select's comma-separated format). The description adds no additional parameter-level semantics beyond implying 'full detail' when select is omitted, so the baseline 3 applies.

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

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

The description clearly identifies the tool as retrieving a specific Acumatica customer with full detail (billing, shipping, credit info). The verb 'Get' and the resource 'specific customer' distinguish it from the list-oriented query_customers sibling, so the purpose is unambiguous.

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

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

The word 'specific' implies the tool is for individual customer lookups rather than bulk queries, but no explicit comparison to query_customers or other alternatives is given. It provides context but leaves exclusions and alternatives to the user's inference.

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

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

With no annotations, the description carries the burden. It discloses that the tool returns warehouse stock quantities, which is useful. However, it does not mention failure modes (e.g., not found), access permissions, or whether the item might be a non-stock item. This is minimal but acceptable for a simple 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?

A single clear sentence with no filler. It front-loads the action and resource, and every word adds value.

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 parameter, this description is fairly complete: it states what is returned (item with warehouse stock quantities). It lacks explicit alternates or edge-case behavior, but given the simplicity, the coverage is good. An output schema does not exist, so the description provides the only return info.

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

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

Schema coverage is 100%: the schema already documents inventoryID as 'Inventory item ID / item code'. The description adds no further parameter semantics, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Get') with a precise resource ('specific Acumatica inventory item') and adds a key detail (warehouse stock quantities). This clearly distinguishes it from siblings like list_inventory_items, which would fetch multiple items, and other get_* 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 use when you need a single, specific inventory item because it says 'specific' and the schema requires an inventoryID. However, it does not explicitly state when to prefer this over list_inventory_items or any other alternative, nor does it mention any prerequisites or exclusions.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It does indicate this is a read operation ('Get') and that the response includes full line item detail, which is useful. However, it does not mention error handling, authentication requirements, or what happens when the invoice is not found, so it is only 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, focused sentence with no extraneous words. It front-loads the key action and resource, and every word contributes to understanding the tool's purpose. This is exemplary 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?

The description is too sparse for the tool's context. With no annotations, no output schema, and no mention of how this relates to sibling tools like query_invoices, the agent is left without guidance on when to reach for this tool versus alternatives. While the schema covers parameters, the description does not provide enough operational context (e.g., response shape, error behavior, or why to choose this over query_invoices) to be considered complete.

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

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

Schema description coverage is 100%, so all parameters (type, select, referenceNbr) are already well-documented in the schema. The description adds no additional parameter-specific meaning beyond implying that the default response includes line items. This matches the baseline of 3 for high schema coverage.

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

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

The description clearly states the verb 'Get' with a specific resource 'a single Acumatica sales invoice' and adds the detail 'with full line item detail,' which distinguishes it from listing tools like query_invoices and other getters like get_shipment. This is a specific and unambiguous purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives such as query_invoices (for querying multiple invoices) or get_shipment. There is no 'when to use' or 'when not to use' context, leaving the agent to infer usage solely from the 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 provided, the description carries the full burden. It discloses a key behavioral trait (returns full line item detail), which is useful context beyond the tool name. However, it does not mention any other behavior such as error handling, access requirements, or response structure, which is a notable gap for a tool without an output schema.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently communicates the tool's core purpose and 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 simple get operation, the description provides sufficient context: it identifies the entity type, indicates singular retrieval, and mentions that full line item details are included. While there is no output schema, the description partially covers what is returned. It is not exhaustive, but it is adequate for this tool's complexity.

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

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

The input schema already describes all three parameters with 100% coverage, so the description is not required to add parameter details. The description does not reference parameters at all, but the baseline of 3 applies because the schema handles the heavy lifting.

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

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

The description uses a specific verb ('Get') with a clear resource ('a single Acumatica purchase order') and adds distinguishing detail ('with full line item detail'). This effectively differentiates it from sibling tools like query_purchase_orders (which implies listing/filtering) and get_sales_order or get_shipment (which are for different entities).

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

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

The description implies usage for retrieving one specific purchase order (as opposed to querying multiple), but it does not explicitly state when to use this over alternatives like query_purchase_orders. It provides context but no exclusions or direct alternative references, so it earns a 3 for implied usage.

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 convey behavior. It implies a non-mutating read operation ('Get') and promises 'full line item detail,' which is useful. However, it does not disclose error handling, required permissions, or response format nuances, leaving gaps.

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

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

Two sentences, front-loaded with the primary purpose and usage condition. Every word earns its place with no redundancy.

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

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

For a simple retrieval tool, the description covers the essential 'what' and 'when.' However, it does not mention the optional 'select' parameter's behavior or describe the return structure in more detail, and since there is no output schema, a bit more would improve completeness.

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

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

The input schema has 100% description coverage, with clear descriptions for all three parameters. The tool description adds no parameter-specific semantics beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Get a single Acumatica sales order') and distinguishes it from sibling tools like query_sales_orders by emphasizing 'full line item detail' and 'specific known order'. This is a specific verb+resource with clear 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?

It provides explicit guidance: 'Use this when you need line-level data for a specific known order.' This tells the user when to choose this tool, though it does not explicitly name alternatives or state 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?

With no annotations provided, the description carries the full burden. It discloses that the tool returns full line item detail, which is useful. However, it does not mention error behavior, permissions, or any side effects, though as a 'get' tool, read-only is implied. More detail on response shape or edge cases would improve transparency.

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 immediately states the tool's purpose and key distinction (line item detail). No filler or redundancy, earning a top 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 simple get tool with 2 parameters and no output schema, the description covers what it does and its key return detail. It lacks explicit usage alternatives, but overall it is sufficiently complete given the tool's simplicity. Not perfect, but above average.

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

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

Schema description coverage is 100%, with both 'select' and 'shipmentNbr' clearly described. The description adds no additional parameter meaning; 'full line item detail' complements the schema's 'header fields' for select but doesn't exceed it. Baseline 3 is appropriate.

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

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

The description 'Get a single Acumatica shipment with full line item detail' clearly states the verb (get), resource (Acumatica shipment), and scope (single, with full line item detail). This distinguishes it from sibling tools like query_shipments, which likely list multiple shipments, and other get/query tools for different resources.

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

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

The description implies usage for retrieving one specific shipment's details, contrasting with query_shipments for listing shipments. However, it does not explicitly name alternatives or state when not to use the tool, leaving the agent to infer context from sibling names.

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

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

With no annotations provided, the description carries the full burden. It notes OData filtering support and listing items, but does not explicitly state that the operation is read-only or disclose any rate limits or side effects. The read-only nature is strongly implied but not confirmed.

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, stating the tool's purpose in the first sentence. The second sentence adds practical usage guidance without unnecessary detail. 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?

Given the tool's simplicity (3 optional parameters, no nested objects, no output schema), the description adequately covers the main purpose and use cases. It could mention pagination limits, but these are already documented in the schema, so the description is sufficiently complete.

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

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

The input schema already provides 100% coverage of parameters with detailed descriptions and examples. The description adds minimal extra meaning beyond mentioning OData filtering and use cases, which is already partially covered 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 'List Acumatica stock/inventory items' with a specific verb and resource. It distinguishes from the sibling tool 'get_inventory_item' by focusing on listing multiple items and exploring inventory.

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 context for use: 'Use this to explore inventory, find items by class or status, or get item lists.' This clearly implies a read-only listing scenario, though it does not explicitly mention alternatives like using 'get_inventory_item' for a single item.

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 communicates that this is a read-only listing operation and adds the clarifying parenthetical '(Generic Inquiries)', but it does not describe output format, pagination, or other behavioral details. This is adequate for a simple listing tool but leaves some ambiguity.

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

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

The description is two sentences, with the main action front-loaded in the first sentence and the usage guidance in the second. Every sentence adds value, and there is no redundancy or filler.

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

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

Given the tool's simplicity (no parameters, no output schema), the description fully covers what the tool does, why it exists, and how it integrates with the broader tool set. It is complete for 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?

The tool has zero parameters, so the schema is fully covered (vacuously). The baseline for 0-parameter tools is 4, and the description does not need to explain any parameters. No additional parameter semantics are required.

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

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

The description clearly states the tool lists all OData entity sets (Generic Inquiries) exposed by Acumatica, using a specific verb ('list') and resource ('OData entity sets'). It also distinguishes from sibling tools by explicitly positioning it as a discovery step before using query_odata.

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?

Provides clear context by instructing to 'Call this first to discover valid entity names before using query_odata', which indicates when to use it relative to a major sibling. It does not explicitly mention when not to use it or address the v4 sibling, but the primary usage scenario is well covered.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only listing operation and provides useful context about the content (raw DAC tables) and the output names. However, it does not explicitly state that it is non-mutating, nor does it disclose possible pagination, rate limits, or return structure beyond the implication that entity set names are returned. This is adequate for a simple list tool 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 two sentences, front-loaded with the core purpose, followed by a meaningful contrast and a direct usage pointer. Every sentence adds value—no filler, tautology, or redundant restatement.

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, no-output-schema listing tool, the description covers purpose, sibling differentiation, and downstream usage. It includes concrete examples (SOOrder, BAccount, InventoryItem, GLTran) to anchor expectations. It does not detail the exact return format or mention potential large result sizes, but given the simplicity, it is sufficiently complete for 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?

The tool has zero parameters, so the baseline is 4. The description adds no parameter-specific detail because none exist, and the input schema is empty, so there is nothing missing. It correctly tells the agent the tool requires no configuration.

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 ('OData v4 DAC entity sets exposed by Acumatica'), and explicitly distinguishes itself from list_odata_entities by clarifying that it exposes raw DAC tables rather than Generic Inquiries. This makes its purpose unambiguous and differentiates it from a close sibling tool.

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

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

The description provides clear guidance: it contrasts with list_odata_entities (Generic Inquiries) and explains that the returned names should be used with query_odata_v4. This tells the agent exactly when to choose this tool and what to do with its output, effectively naming the alternative and follow-up.

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 responsibility. It implies a read-only operation through 'list and filter' and gives a purpose, but it does not disclose pagination behavior, return format, or access requirements. It is minimal and not misleading, but lacks rich behavioral context.

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

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

Two concise sentences, front-loaded with the primary action ('List and filter Acumatica customers'), with no unnecessary words. It earns its place by adding a use case.

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 straightforward list tool, the description is fairly complete: it covers the purpose and usage context. It does not explain return values, but no output schema exists and the parameter schema covers query mechanics. It could mention alternatives like get_customer, but that is not critical.

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

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

Schema description coverage is 100%, so the parameters are fully documented with examples. The description adds a small hint about filtering by credit terms, which is not in schema examples, but it does not explain syntax or add substantial meaning beyond the schema.

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

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

The description clearly states it lists and filters Acumatica customers, using a specific verb and resource. It distinguishes itself from siblings like get_customer (single record) and query_* tools for other entities by focusing on customer list operations.

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 clear usage context: 'Use this to look up customers by name, class, status, or credit terms for analytics and reporting.' It does not explicitly mention alternatives or when not to use it, but the implied use case is well-defined.

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. 'List and filter' implies a non-mutating read operation, which is useful, but it does not mention pagination behavior (top/skip), default limits, or that the result is a collection. This is adequate but not rich.

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

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

The description is two sentences, front-loaded with the primary action and resource, then followed by usage examples. Every sentence adds value, and there is no fluff or redundancy.

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

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

Given the straightforward nature of a list/filter tool with a well-covered schema, the description covers the main use cases and indicates the return is a list. It omits details like pagination defaults, but the schema already documents top/skip, and 'list' implies an array. It is reasonably complete for an AI agent.

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

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

Schema coverage is 100%, so the baseline is 3. The description does not add any additional meaning beyond the parameter names and schema descriptions; the tool name and context align with the parameters, but no extra guidance is provided.

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 ('List and filter') and the resource ('Acumatica sales invoices (AR)'), making the tool's purpose unmistakable. It also distinguishes from siblings like get_invoice (singular fetch) and query_sales_orders (different document type) by specifying the AR invoicing domain.

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 explicit use cases ('revenue analytics, finding open or overdue invoices, summarizing invoice activity by customer'), which helps an agent decide when to use this tool. However, it does not mention when NOT to use it, such as a single-invoice lookup via get_invoice, so it lacks full exclusion guidance.

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

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

With no annotations, the description carries the burden of disclosure. It adds value by naming supported OData operators and the prerequisite to list entities, but it omits details like return format, authentication, or error behavior. This is adequate but not comprehensive.

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

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

The description is only two sentences, front-loaded with the tool's purpose, and every word serves a function. It avoids restating schema details and is highly efficient.

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

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

Given the tool's complexity (6 params, no output schema, no annotations), the description covers purpose, prerequisite, and supported options. However, it does not mention the response format or clearly distinguish between query_odata and query_odata_v4, leaving minor 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 coverage is 100%, with each parameter having a detailed description. The tool description merely lists the OData options ($filter, $select, etc.) without adding new meaning beyond what the schema already provides, so it meets the baseline but adds no extra 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 clearly states the tool queries any Acumatica Generic Inquiry via OData, using a specific verb and resource. It also distinguishes from sibling tools by emphasizing the generic nature and instructing to use list_odata_entities first, though it does not explicitly differentiate from query_odata_v4.

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?

Provides clear context by instructing users to call list_odata_entities first to discover valid entity names. However, it does not mention exclusions or alternative tools like query_odata_v4, so it lacks an explicit when-not-to-use statement.

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

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

With no annotations, the description carries the full burden. It discloses a critical behavioral trait: large tables (e.g., GLTran) will timeout without a filter, and advises always using $select to limit returned fields. This goes beyond the schema and provides valuable operational context, though it doesn't address error handling or response format.

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

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

The description is five sentences, all informative and earning their place. It front-loads the core purpose, gives entity examples, and ends with critical usage warnings in clear format. No fluff or unnecessary repetition.

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

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

The tool has 6 parameters, no output schema, and moderate complexity. The description covers purpose, entity discovery, and critical filtering guidance. It could mention error behavior or pagination details, but the schema covers parameters and the guidance is sufficient for most 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?

Schema description coverage is 100%, with parameter descriptions that include examples and formats (e.g., filter datetimeoffset, entity names). The description adds no new parameter semantics beyond emphasizing $select usage, so the baseline 3 applies.

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

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

The description clearly states the tool queries any Acumatica DAC table directly via OData v4, with a specific verb and resource. It lists example entities (SOOrder, BAccount, InventoryItem) and distinguishes itself from higher-level sibling tools by emphasizing raw DAC access.

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?

Provides actionable guidance: tells users to use list_odata_v4_entities to discover valid entity names, and warns to always apply filters and $select to avoid timeouts. However, it doesn't explicitly contrast with sibling tools like query_sales_orders, though the 'directly via OData v4' wording implies a low-level 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?

With no annotations, the description carries the transparency burden. 'List and filter' implies a non-mutating read operation, and the use cases add context. However, it does not explicitly state read-only behavior, return format, pagination details, or potential side effects, leaving gaps that could be filled.

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 exactly two sentences with no wasted words. The first sentence states the core function, the second provides usage context. It is front-loaded and easily scannable.

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

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

For a simple list/filter tool with fully documented parameters, the description is mostly complete. It clearly implies a list return via 'List and filter' and covers use cases. However, since there is no output schema, explicitly stating the return structure (e.g., a list of purchase order objects) would improve completeness.

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

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

The input schema has 100% coverage, documenting each parameter with descriptions and examples. The tool description adds no additional parameter semantics beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description uses the specific verb 'List and filter' with the resource 'Acumatica purchase orders', clearly indicating a query operation. It also lists concrete use cases (procurement analytics, finding open/pending POs, summarizing spend by vendor) that distinguish it from singular get_purchase_order and sales order query 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 explicitly states when to use: 'Use this for procurement analytics, finding open or pending POs, or summarizing spend by vendor.' This provides clear context but does not explicitly mention alternatives or when not to use it, though sibling tools like get_purchase_order imply the contrast.

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 transparency burden. It states the tool is a query and supports OData filtering/ordering, implying read-only behavior. But it does not disclose output shape, default pagination limits, or potential performance impacts of includeDetails — though some of this is covered 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 two sentences long, front-loaded with the core purpose and followed by usage context and capability. Every sentence adds value without redundancy.

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

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

The description is sufficient for a straightforward query tool: it names the inquiry, explains its intended use, and mentions key OData features. The schema provides rich parameter details, compensating for the absence of an output schema or annotations, though it could have noted default pagination behavior explicitly.

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 describes all six parameters with 100% coverage, including examples and constraints. The description adds no parameter-level meaning beyond mentioning OData $filter/$orderby support, which is also in the schema, so the baseline 3 is appropriate.

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

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

The description clearly states the tool queries Acumatica sales orders via the SO-SalesOrder generic inquiry, with a specific verb and resource. It also explicitly positions it for lists, analytics, and summaries, distinguishing it from the sibling get_sales_order tool.

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

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

The description provides clear use cases ('lists, analytics, and summaries') and notes OData $filter and $orderby support, giving context for when to use it. However, it does not explicitly name alternatives or state when not to use it, leaving a minor gap.

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

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

No annotations are provided, so the description carries the full burden. 'List and filter' strongly implies a read-only operation, but the description does not explicitly confirm safety or disclose behavioral details such as pagination behavior, rate limits, or return format. It adds some context about use cases but not deeper transparency about side effects or limitations.

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

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

The description is two concise sentences. The first sentence states the core function; the second lists example use cases. No redundant or irrelevant information, and the content is front-loaded.

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

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

For a simple list/filter tool with 4 well-documented parameters and no output schema, the description is mostly complete. It explains the tool's purpose and common use cases. However, it does not mention that results can be paginated (via top/skip) or that it returns a collection, but these are inferable from the parameters. Given the simplicity and read-only nature, the description sufficiently supports 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 100%, with each parameter thoroughly described including examples. The tool description adds only high-level use cases (analytics, tracking, finding) that map loosely to the filter parameter, but provides no additional semantic meaning beyond the schema. Per guidelines, baseline 3 is appropriate when schema covers everything.

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

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

The description clearly states the tool's function: 'List and filter Acumatica shipments.' This is a specific verb+resource construction that distinguishes it from sibling tools like get_shipment, which likely retrieves a single shipment. The mention of analytics, tracking, and finding by customer or warehouse further clarifies purpose.

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

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

The description provides explicit use cases ('Use this for shipment analytics, tracking open or completed shipments, or finding shipments by customer or warehouse'). This gives clear context for when to choose this tool over others, though it does not explicitly name alternatives or state 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.