warp-agent-mcp

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

Annotations already establish readOnlyHint=true, and the description does not contradict that. It adds genuinely useful context beyond the annotations: the auth requirement, the single upstream population (agent API /bookings), and the guarantee that the headline total reconciles with every breakdown.

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 what is summarised and immediately followed by the reconciliation guarantee. 'Auth required.' is terse but earns its place as a call prerequisite.

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

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

With no output schema, the description adequately names what comes back (count, spend, three breakdowns) and the scoping population. Only minor gaps remain, such as the response shape for each breakdown and how limit truncation affects the figures.

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 limit and group_by are already fully documented, including the default/max and the fact that group_by only orders the response. The description's 'over a window' and 'split by mode, status and lane' loosely echo those parameters but add no syntax or format detail 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?

States a specific verb (summarise) and resource (your own shipping history) and enumerates the outputs: booking count, spend, and splits by mode, status and lane. This clearly separates it in kind from listing siblings like list_bookings or lane_history, though no sibling is named outright.

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

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

Usage is implied rather than stated: an agent can infer this is the aggregate/summary counterpart to the raw list tools, and 'over a window' hints at the recency scope. There is no explicit when-to-use or when-not-to-use guidance and no alternatives 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?

Annotations already indicate readOnlyHint=false, destructiveHint=false, but the description adds significant behavioral detail: it only proposes now, books later automatically only with owner approval, and over-ceiling weeks book nothing and notify. It also states the recurring nature and the ceiling constraint. No contradictions with annotations.

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

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

The description is dense but well-structured, front-loading the core purpose and then explaining the approval and ceiling mechanics. Some redundancy exists ('nothing books now' and 'nothing ever books without approval'), but it remains efficient. It is appropriately sized for the complexity of the tool.

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

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

For a tool with 7 parameters, nested objects, and no output schema, the description covers the overall workflow and key constraints (approval, ceiling, recurrence). It does not explain the quote/book payload structure, but the schema already does. The description adequately complements the schema for an agent to understand the tool's purpose and invocation flow.

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 each parameter is already documented in the schema. The description does not elaborate on parameter-specific details but does reference the ceiling concept. Since the schema covers parameter meaning thoroughly, the description adds marginal value beyond schema, so baseline 3 is appropriate.

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

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

The description clearly states the tool sets up a recurring weekly shipment automation, with specific behavior: re-quoting and auto-booking under a ceiling, after owner approval. It explicitly differentiates itself from immediate booking tools by stating 'THIS TOOL ONLY PROPOSES — nothing books now'. The verb 'set up' and resource 'recurring lane' are precise, and the description distinguishes it from siblings like book or batch_book.

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 guidance on when to use: for standing orders needing weekly re-quoting and auto-booking, and clarifies it does not perform immediate booking. It notes the approval requirement and over-ceiling behavior. Although it does not name specific alternative tools, the context makes it clear this is for automation versus one-off bookings, and the 'Auth required' note adds operational context.

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

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

Beyond the readOnlyHint annotation, the description adds critical behavioral context: entries with confirmation_required did not book autonomously and fell back to owner confirmation, and it lists the specific checks performed at commit time. The 'Auth required' note also adds operational nuance not in annotations.

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

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

Two dense sentences, front-loaded with the tool's purpose ('Authorization record...'), followed by the important behavioral caveat. Every phrase 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 single-parameter read-only tool, the description covers the record's contents, the confirmation_required exception, and safety/read-only status. It stops short of stating the return shape (e.g., list vs single object), but the token parameter and purpose make that largely clear.

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 a clear description of token (automation token from automate_lane). The main description does not address parameters, but the schema carries that weight, so no additional explanation is needed.

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

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

Description clearly identifies it as an authorization record for an automation's bookings, specifying the content (checks passed, shipment id, confirmation_required flag). However, it lacks an explicit action verb like 'get' or 'list', so it reads more as a resource definition than an operation.

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

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

The description implies this is the place to inspect automation booking authorization decisions ('one entry per booking attempt'), but it does not explicitly contrast with sibling tools like list_bookings or events. It mentions read-only and auth required, which helps, but no explicit when/when-not guidance.

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

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

Annotations only carry destructiveHint=true, so the description adds real value: sequential execution, one card charge per row, per-row Booked/Failed outcome, and the session-scoped quote_id expiry warning. It stops short of stating what happens to already-charged rows if a later row fails, or any refund/permission detail, so it is strong but not exhaustive.

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

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

Four sentences, front-loaded with the core action and followed by the routing rule, the required key, the address-inheritance shortcut, and the return shape. Dense and mostly waste-free, though the address-inheritance sentence runs long relative to its informational payload.

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 destructive 8-param batch mutation with no output schema, the description covers the return value (progress card with per-row status and tracking), the batching contract, and the inheritance defaults. Remaining gaps are edge-case failure/refund semantics, which are secondary but not covered by any structured field.

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 schema coverage at 63%, the description compensates by explaining the shared_* inheritance model (per-row values fall back to top-level shared values) and the warehouse → many destinations case. The quote_id session constraint and row-count economics are also surfaced. It does not add format detail for windows or accessorials, which the schema leaves bare.

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

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

States a specific verb (book), resource (already-quoted lanes), and scope (MANY in ONE call), and explicitly distinguishes itself from the sibling `book` by forbidding the loop pattern. An agent can route between batch_book, book, and batch_quote without opening any schema.

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

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

Names the trigger conditions verbatim ('book all of them', 'book rows 1, 3, 5'), the required prerequisite (after batch_quote, using the same quote_id), and the explicit anti-pattern (do NOT call book in a loop). This is textbook when/when-not/alternative guidance.

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

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

Annotations only declare readOnlyHint=true, so the description carries the burden of explaining behavior, and it does so richly. It discloses the return format (a single batch-quote card with one row per lane), the output fields (origin → dest, mode, pallets, price, transit), that each row keeps quote_id, and that rows can be individually booked. It also clearly warns against overclaiming comparison coverage, which is exactly the kind of behavioral context an agent needs.

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

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

The description is compact for the amount of behavioral nuance it carries, and the most important capability is front-loaded. There is a small redundancy—'NOT all-mode or all-carrier comparison' and 'Never imply this tool compared every carrier' say similar things—but both serve as deliberate guardrails. Overall, every sentence earns its place for a tool with no output schema.

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

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

Given that there is no output schema, the description fully compensates by spelling out the return shape, row fields, quote_id retention, and booking follow-up. It also covers limitations and sibling routing, which is more than sufficient for an agent to invoke the tool correctly and interpret its response. The input side is fully handled by the high-coverage schema.

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

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

Schema coverage is 100%, so the schema already documents the lanes array and nested properties. The description adds value by clarifying the row-to-quote mapping ('each row maps to one quote'), the 50-lane invocation model, and the per-row mode default, which reinforces but does not merely duplicate the schema. It doesn't need to restate each lane field, so this exceeds the baseline.

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 ('Price'), a clear resource ('up to 50 lanes in one call'), and the per-row mode behavior. It differentiates this tool from siblings like compare_modes and ltl_market_options by explicitly stating what it is NOT ('NOT all-mode or all-carrier comparison'). An agent can confidently distinguish this from batch_book, ltl_quote, and compare_modes without opening schemas.

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

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

It gives explicit when-to-use guidance ('Price up to 50 lanes in one call') and names alternatives with their trigger conditions: compare_modes for Compare All and ltl_market_options for LTL carrier alternatives. It also states a clear exclusion: 'Never imply this tool compared every carrier.' This leaves no ambiguity about when to select this tool versus a sibling.

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

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

The annotation set is thin (only destructiveHint=true), so the description carries most of the burden. It usefully discloses auth requirements, the no-memory 'every time' rule for delivery data, and the conditional pickup rule. However it never says what committing a booking actually does commercially (cost incurred, reversibility, confirmation behavior), which matters for a destructive write 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?

Four tight sentences, front-loaded with what the tool does, then preconditions, then the conditional pickup rule and the pre-call instruction. Every sentence carries information, with only mild redundancy between 'requires ... every time' and the schema's own repetition.

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

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

For an 8-parameter tool with nested objects and no output schema, the description covers the essential call-time requirements (auth, required inputs, conditional pickup, pre-call data gathering). The main remaining gap is the outcome/return behavior of a successful booking, which the description does not address.

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 schema already documents all 8 parameters including nested objects and required fields, establishing a baseline of 3. The description reinforces that quote_id and full delivery are required and explains quote_id provenance, but adds little semantic detail beyond what the schema fields already state.

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

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

States a specific verb ('book') and resource ('quoted shipment') and explicitly ties it to output from quote tools (Warp or market carrier), which separates it from siblings like ftl_quote, ltl_quote, and batch_quote. An agent immediately understands this is the terminal booking step after quoting.

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?

Gives clear preconditions: quote_id must come from a quote tool, delivery details are mandatory 'every time', and pickup may be omitted only when a default shipper is saved. It also instructs collecting missing details before calling. It does not differentiate when to use book vs batch_book or multistop_book, so it stops short of a 5.

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

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

The readOnlyHint annotation confirms this is a non-destructive read operation. The description adds 'firm price', implying a committed quote rather than just a range, but it doesn't disclose if rates are guaranteed, whether the quote expires, or if it requires login. With annotations covering safety, a 3 is appropriate.

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, well-structured sentence that front-loads the equipment, scope, and output. No wasted 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 quote tool with 11 parameters and no output schema, the description is concise but covers the key differentiators. It could benefit from mentioning that the quote is based on the provided ZIPs and dimensions, but it's largely complete given the schema's thorough annotations.

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 parameters are fully documented in the schema. The description adds context by clarifying the pallet range (1-12) and that it's a 26' truck, but doesn't add additional parameter-specific detail beyond the schema. Baseline 3 is exceeded due to helpful constraint reinforcement.

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

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

The description identifies the specific equipment (26' box truck), the quantity constraint (1-12 pallets), and the output type (firm price). It clearly distinguishes itself from siblings like van_quote, ftl_quote, or ltl_quote by naming the exact mode.

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 you need a box truck quote) and states the core constraint. However, it doesn't explicitly say when to choose this over van_quote or ftl_quote (e.g., pallet count thresholds), leaving some ambiguity.

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

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

Annotations declare readOnlyHint=true and destructiveHint=false, and the description does not contradict them. The description adds behavioral details: it excludes mismatched/unknown terms, keeps losses, separates quoted opportunities from invoice differences, and lists non-actions (does not fetch rates, verify documents, annualize savings, or book). This goes beyond the annotations, though it does not specify output format or error handling.

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 three sentences: the first states the core purpose, the second describes handling of mismatches and losses, and the third lists exclusions and a constraint. Every sentence adds value and is front-loaded with the main action. No wasted 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?

The tool has a complex input schema (array of objects with many required fields) and no output schema. The description explains what it does with inputs but does not describe the return format (e.g., list of differences, summary, or error handling). Given the complexity, the description should at least hint at the output structure, which is missing. The constraint 'up to 50 shipments' is in the schema but not emphasized in the description.

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 mentions 'invoice/quote amounts' (baseline_amount_usd, candidate_amount_usd) and 'explicit comparability evidence' (comparison_evidence), but it does not explain the enum fields (baseline_kind, candidate_kind, included_charges, service_requirements, shipment_requirements) or the source fields beyond what the schema already provides. The schema itself has descriptions for several fields, but the description adds little to 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 states a specific action (calculate USD cost differences), a specific resource (up to 50 shipments using supplied amounts and evidence), and explicitly lists exclusions (fetch rates, verify documents, annualize, book). This clearly distinguishes it from sibling tools like compare_modes (mode comparison) and batch_quote (quotation).

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: it requires supplied invoice/quote amounts and explicit comparability evidence, and it excludes mismatched/unknown terms. It also states what it does not do (fetch rates, verify documents, annualize, book), which hints at when to use other tools, but it does not explicitly name an alternative or provide a clear 'use this when...' directive. The constraint 'One candidate per shipment per call' further clarifies 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?

Beyond the readOnlyHint annotation, the description discloses that dims are optional with a standard pallet assumption, explains the benchmark_market time cost (15-25s), and ensures modes that can't be priced are returned with reasons, preventing silent omissions.

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 front-loaded with the main purpose, every sentence adds value, and it is well-organized without redundancy. It efficiently conveys all necessary information.

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

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

Given no output schema, the description fully explains the return value including winning mode, rate, transit, quote_id, runner-up comparison, and unavailable modes with reasons. It also covers the benchmark option and the tool's read-only nature, making it completely informative for an 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?

Input schema has 100% description coverage, so baseline is 3. The description adds some context like default dimensions and benchmark time cost, but does not significantly enhance parameter understanding beyond 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 it is the single call for comparing freight modes, returning a decision-complete recommendation. It distinguishes itself from individual quote tools by emphasizing efficiency and comprehensive results.

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?

Explicitly advises to prefer this tool over individual quote tools for mode comparison, and clarifies that it is quote-only and the quote_id should be passed to the `book` tool for booking. Provides clear when-to-use and when-not-to-use guidance.

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

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

Annotations declare readOnlyHint=true, so the tool is a read-only lookup. The description adds that pricing is done 'through real quotes with bookable quote ids' but does not state that the tool itself is non-destructive. It adds important context including the behavior for unconsolidatable loads (they come back with a reason) and how to handle trucks priced above LTLs (shown with recommended:false; don't hide). The description also notes 'Auth optional — works keyless like the quote tools.' This is valuable behavioral context beyond annotations. However, it does not specify whether the returned quote IDs are always valid or if they expire, which would be useful transparency. Score 4 because it adds significant behavioral detail beyond the readOnlyHint.

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

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

The description is a single dense paragraph that packs in purpose, usage guidelines, behavioral notes, and next steps without wasted words. It is front-loaded: the first sentence defines core functionality completely. Every subsequent sentence adds new information: clustering criteria, pricing logic, use cases, failure reasons, honesty policies, next action, and auth requirements. It is concise yet comprehensive.

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

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

Given the tool has 2 parameters, 100% schema coverage, no output schema, and no nested objects, the description is remarkably complete. It explains the entire workflow: clustering logic, pricing comparison, recommended flag behavior, failure reasons, and the action path (call book). The description even relays expected agent behavior ('relay reasons honestly' and 'don't hide' recommended:false trucks). For a tool without an output schema, the description compensates thoroughly by describing what will be returned and how to handle it. Context signals indicate low complexity, and the description fully addresses all 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 100%, so the schema already documents all parameters and their descriptions. The description adds semantic value by explaining how parameters are used in the overall consolidation logic: 'clusters loads sharing an origin+destination zip whose pickup dates fall within window_days (default 3) that together fit one 53' dry van.' It also gives a default value for window_days (3). This clarifies the role of parameters beyond the schema descriptions. The description explains what the loads array represents and the criteria for clustering. Score 4 because it adds meaningful usage context while schema already has good parameter 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 tool finds consolidation savings across 2-12 upcoming loads by clustering loads sharing origin+destination zip and pickup date window that fit one 53' dry van, then pricing each cluster both ways (combined FTL vs sum of LTLs) through real quotes with bookable quote IDs. This provides a specific verb (find/find consolidation savings) and resource (loads), and distinguishes it from sibling tools which are individual quote/booking 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 when the user has several loads to ship this week, asks if anything can ride together, or wants to cut freight spend.' It also tells when not to keep hidden: 'A truck pricing above its LTLs is shown with recommended:false; don't hide it.' It provides next-step action: 'To act on a proposal, call `book` with the consolidated truck's quote_id.' It also gives instructions for handling failures: 'Loads that can't consolidate come back with the reason... relay reasons honestly.'

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

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

Annotations already indicate destructiveHint=true. The description adds useful context: auth requirement and the id format (starts with lt_). No contradictions.

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. Every part is essential.

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 delete tool with one parameter and no output schema, the description provides all necessary context: action, resource, id format, and auth requirement.

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

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

Schema coverage is 100%, and the schema already describes the parameter well. The description repeats this information without adding new meaning. 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 explicitly states 'Delete a saved load template by its id', using a specific verb and resource. It clearly distinguishes from sibling tools like 'save_load_template' and 'load_templates'.

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 mentions 'Auth required', but does not provide explicit guidance on when to use this tool versus alternatives or when not to use it. No exclusions or prerequisites 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?

Annotations already declare readOnlyHint=true, so the description's mention of 'Auth required' adds value beyond annotations. It discloses the return type (timeline of events) but omits details like pagination, ordering, or error handling. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence with parenthetical examples. Every word adds value; no redundancies.

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 1-parameter retrieval tool with no output schema, the description covers purpose, auth requirement, and example content. Minor gaps (e.g., no mention of pagination) are acceptable 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?

Schema coverage is 100% and the single parameter 'shipment_id' is described in the schema as 'Shipment ID from book response'. The tool description adds no further parameter details, so it meets the baseline but does not exceed 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 clearly states the action ('Get') and resource ('full tracking event history for a shipment'), with concrete examples (pickups, in-transit updates, deliveries). It distinguishes from siblings like 'track' by specifying 'full history' and 'timeline'.

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 mentions 'Auth required' but does not provide explicit guidance on when to use this tool versus alternatives like 'track' or 'get_documents'. No exclusion criteria or alternative recommendations are given.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows it is non-destructive. The description adds value by confirming it is 'Guidance only' and enumerating specific actions it does not perform (read files, fetch rates, schedule, book), which gives more context than the bare annotations.

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

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

Two sentences with no filler. The main action and outputs are front-loaded, followed by the scope limitation and usage trigger. Every sentence earns its place, making it 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?

For a single-parameter tool with no output schema, the description covers the purpose, the outputs (CSV headers, starter prompt), the exact use cases, and the limitations. It does not detail the exact format of the CSV headers or prompt, but that is minor and not required for correct invocation.

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

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

The sole parameter 'workflow' has an enum with three values, and the description names the corresponding use cases ('shipment quoting, weekly freight comparison, or invoice review'), mapping directly to the enum options. This adds meaning beyond the raw schema, which has 0% description coverage, so the description compensates adequately.

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: it provides CSV headers and a starter prompt for three distinct workflows. It clearly distinguishes itself from siblings by explicitly saying it is 'Guidance only' and does not read files, fetch rates, schedule work, or book, making its scope 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?

It gives an explicit trigger condition: 'Use this when an operator asks how to start or supplies invoices/a shipment sheet.' It also lists exclusions (does not read files, fetch rates, etc.), which clarifies what it is not for, effectively routing the agent away from action-oriented 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?

Annotations already declare readOnlyHint=true, so the agent knows the tool is safe. The description does not contradict annotations and adds a minor behavioral cue by stating minimal input requirements, but it does not elaborate on the quote generation process or output 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?

A single sentence that is front-loaded with the core action ('Quote a full truckload') and immediately clarifies the essential scope and required fields. No wasted words 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?

The description lacks details about the output format (e.g., price, transit time) and does not disambiguate from the sibling tool 'van_quote', which may cause confusion. Given no output schema, more information on return values 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?

With 100% schema description coverage, the base expectation is a 3. The description adds value by clarifying that only origin, destination, and date are required, implicitly marking other parameters as optional. This helps the agent understand which fields are essential for the quote.

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 explicitly states that the tool quotes a full truckload (53' dry van) and highlights the minimal required fields (origin, destination, date). This clearly distinguishes it from siblings like ltl_quote or box_truck_quote.

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 implicitly signals when to use this tool by specifying 'full truckload (53' dry van)' and emphasizing that only three fields are required. It lacks explicit exclusions or alternative recommendations, but the context is clear enough for an AI agent to select it appropriately.

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

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

Annotations already mark readOnlyHint=true. Description adds that auth is required and returns download URLs, providing useful behavioral context beyond the annotation.

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

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

Three concise sentences: purpose, return/auth, and a specific usage note. No fluff, front-loaded, every sentence 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 simple tool with 2 params and no output schema, description covers purpose, return value, auth, and special case. Could mention pagination or empty results but not critical; fairly 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 covers both parameters fully. Description adds value by clarifying that document_type filters to one type and gives common values ('bol', 'pod'), and explains special behavior for 'bol' fetching external BOLs.

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

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

Description clearly states the tool lists shipment documents with examples (BOL, POD, customs forms) and mentions returning download URLs. Differentiates from sibling tools like get_invoice which deals with financial documents, no direct competitor.

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 specific guidance on using document_type='bol' for external BOLs and notes auth required, but does not explicitly state when to avoid this tool or mention alternatives among siblings.

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

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

Annotations already declare readOnlyHint=true, so no contradiction. The description adds value by specifying the conditional context ('for a delivered shipment') and the need for authentication, which annotations do not cover.

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 with no redundant words. It front-loads the key action and resource, making it efficient for an agent to parse.

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

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

With no output schema, the description partially compensates by mentioning returned data (line items, taxes, payment status). However, it omits expected response format (e.g., JSON vs. file) and behavior for non-delivered shipments, leaving gaps for a one-parameter tool.

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

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

Schema description coverage is 100%, with 'order_id' fully documented. The description does not add parameter-specific meaning beyond the schema, so 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 verb 'Retrieve' and resource 'invoice for a delivered shipment', listing specific contents (line items, taxes, payment status). This distinguishes it from sibling tools like 'get_documents' (general documents) and 'payment_status' (only 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 notes 'Auth required' and implies use after shipment delivery, but lacks explicit guidance on when not to use or alternatives (e.g., 'get_documents' for other shipment docs). No exclusions 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?

Annotations already declare readOnlyHint=true, so the description adds value by disclosing authentication requirements and the specific data returned (past shipments, last consignee, counts), which goes beyond the annotated safety profile.

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 that clearly states purpose and key details. Every word contributes value, 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?

Given the tool's simplicity (no parameters, read-only, no output schema), the description adequately covers purpose, required authentication, and return data. It does not specify format or pagination, but for a simple history endpoint it is sufficient.

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?

No parameters exist; baseline score is 4 as per guidelines. The description does not need to compensate for parameter documentation since schema coverage is 100%.

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

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

Description uses specific verb 'Get' with clear resource 'shipping history for your lanes', and lists example data (past shipments, last consignee, counts). This distinguishes it from sibling tools like analytics or quote_history, which serve different 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?

No explicit when-to-use or when-not-to-use guidance is provided. The description only states 'Auth required', but lacks context on when this tool is preferred over alternatives like analytics or quote_history.

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

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

Annotations only declare readOnlyHint=true, so the description adds real value: ordering (newest first), result scope (all channels, all time, including cancelled), and an auth requirement. It also discloses that it renders an interactive shipments card, which is behavior an agent cannot infer from structured fields.

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?

Front-loaded with the core purpose and scope in the first two sentences; the auth note and card-rendering detail follow. Every sentence carries information, though the UI-rendering sentence is the least load-bearing for an agent.

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

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

With no output schema, the description appropriately covers return scope and ordering, and the readOnlyHint annotation plus the stated auth requirement cover the safety profile. Pagination behavior is only in the schema's limit description, a minor gap for a tool this simple.

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

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

Schema coverage is 100% and there is a single optional limit parameter fully documented in the schema, so the baseline is 3. The description's 'newest first' hints at ordering but adds no syntax or format detail 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?

States a specific verb and resource ('List recent bookings for this API key, newest first') and explicitly contrasts its scope with the sibling shipper_profile, so an agent can distinguish it without opening any schema.

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

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

Names the alternative (shipper_profile) and precisely characterizes the scope difference — all channels, all time, including cancelled, versus 180-day non-cancelled agent-API counts — giving clear context for selection. It stops short of stating an explicit when-not rule, but the comparison is strong routing guidance.

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

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

The description adds value beyond the readOnlyHint annotation by specifying that the tool lists reusable shipment configs with fields (name, dims, weight, commodity) and requires authentication. It confirms the read-only nature without contradicting annotations.

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

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

The description is only two sentences, both highly informative. The first sentence states the primary function, and the second provides usage guidance. No redundant or unnecessary 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?

Given no parameters, a readOnlyHint annotation, and no output schema, the description is complete. It clearly explains what is listed, the purpose, and the auth requirement, leaving no 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?

The input schema has no parameters, and the description effectively explains why by describing the type of content returned. It adds meaning beyond the schema by detailing the fields in a template and the use case.

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 starts with 'List the agent's saved load templates', clearly specifying the action and resource. It explains what templates contain and distinguishes from sibling tools like save and delete by focusing on listing and recalling for quoting/booking.

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 it: to recall a template for quoting/booking a repeat load. It also mentions 'Auth required' as a prerequisite. However, it does not provide explicit exclusions or alternatives, which would make it a 5.

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

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

The description adds 'Auth required' beyond the annotations (which only have readOnlyHint=true). This informs the agent of a behavioral requirement. No contradictions with annotations.

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

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

Two sentences, front-loaded with purpose and benefit. Every sentence earns its place; no wasted 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 read-only list tool with no parameters, the description fully informs the agent of what it does, why to use it, and the authentication requirement. No output schema needed as the description explains the content.

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

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

The input schema has zero parameters, so schema coverage is 100%. The description adds value by explaining that the list contains pickup/delivery addresses, which is useful context 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 uses a specific verb ('List') and resource ('saved pickup/delivery locations'), and explains the benefit ('reuse them when booking'). It clearly distinguishes from sibling tools like 'list_bookings'.

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 when to use ('so you can reuse them when booking instead of re-typing addresses'), providing clear context. No explicit exclusions or alternatives are given, but it is adequate for a simple list 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?

Discloses that it 'Saves credentials locally so booking tools work', which is a behavioral trait beyond annotations (readOnlyHint=false, destructiveHint=false). No contradictions.

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, no filler. Front-loaded with purpose, then key behavioral detail and usage guidance. Every sentence 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?

No output schema, but tool is simple authentication. Description explains side effect (saves credentials). Could mention error handling or session duration, but still reasonably complete given 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 provides descriptions for both parameters (email and password) with 100% coverage. Description does not add extra meaning beyond the schema, so baseline 3 is appropriate.

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

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

Description clearly states 'Log in to Warp with email and password', specifying the verb (log in) and resource (Warp). No ambiguity, and it distinguishes from sibling tools which are about shipping/booking functions.

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?

Explicitly says 'Call this if the user needs to authenticate or if payment_status says no key is configured', giving clear when-to-use guidance. Could elaborate on when not to use (e.g., if already logged in), but still effective.

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

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

Annotations already indicate readOnlyHint=true, and the description adds valuable behavioral context: the tool is slow (15s), returns a ranked list of 30+ carrier rates. No contradictions with annotations.

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

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

Three sentences, front-loaded with purpose, then usage instructions, then constraints. Every sentence is necessary and efficient, no fluff.

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

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

Given complexity (14 params), full schema coverage, no output schema, and annotations, the description explains the tool's workflow position, output structure (ranked list of 30+ rates), and behavior. Sufficient for an agent to use 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?

Input schema has 100% coverage with descriptions. The description adds meaning by indicating that parameters are the same as ltl_quote, providing cross-tool consistency. This is useful beyond the schema alone.

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

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

The description clearly states it performs a multi-carrier LTL comparison, returns 30+ carrier rates ranked by price, and distinguishes itself from sibling tools like ltl_quote by specifying its role in the workflow.

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?

Explicitly instructs to call IMMEDIATELY AFTER ltl_quote with the same parameters, provides context for when it's useful (compare carriers, pick specific one), and includes a clear constraint: do not declare a winner or recommend a carrier.

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?

Adds significant behavioral context beyond readOnlyHint annotation: describes speed (~1-2s), inline loading indicator, default pallet assumption, and the need to call ltl_market_options. No contradiction with annotations.

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

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

Description is somewhat lengthy but front-loaded with key purpose and speed. Every sentence serves a purpose, though some could be slightly more concise.

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 14 parameters, no output schema, and no nested objects, the description comprehensively covers behavior, timing, default assumptions, and follow-up actions. It fully satisfies the contextual needs for an agent 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?

Although schema coverage is 100%, description adds critical semantics: explains that missing dimensions default to a standard pallet, and that providing dims yields an exact firm quote. This compensates for any ambiguity in parameter 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 tool quotes an LTL shipment, returns Warp's all-inclusive rate fast, and distinguishes it from sibling tools like ltl_market_options by specifying the follow-up action.

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 explicit guidance: when to quote, to follow up with ltl_market_options, to not block on dimensions, to quote even without dims, and to not editorialize results. Also suggests comparing LTL with other modes when applicable.

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

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

The description materially extends the annotations' destructiveHint=true by specifying that 'cancel' is permanent and that 'skip_next' stops charges/bookings for one week. It also discloses the auth requirement and that resume/reactivate are gated behind the account owner's emailed approval link, with no contradiction to the annotations.

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

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

Every sentence earns its place: scope, action semantics, stop-only boundary, and auth requirement. The core verb+resource is front-loaded and there is no filler or repetition.

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

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

For a simple two-parameter tool with no output schema, the description covers the critical side effects, auth, and unsupported actions well. The only notable gap is that it does not describe what a 'status' call returns, although the action name and read-only hint partially cover that.

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

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

The input schema already documents both required parameters at 100% coverage, which sets a baseline of 3. The description adds useful action-level semantics beyond the schema, including permanence of cancel and the one-week billing effect of skip_next.

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 opening clause 'Check or stop a recurring lane automation' names specific verbs and a concrete resource, and the action list makes the scope explicit. It is immediately distinguishable from sibling creation tool automate_lane and related receipt/lane-history 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 frames the tool as STOP-ONLY and warns there is no agent-side resume, reactivate, or ceiling change, so an agent knows when not to use it. It does not directly name sibling alternatives such as automate_lane in the description, though token provenance in the schema points there, which keeps it just shy of a 5.

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

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

Discloses that no card charge fires and auth is required, adding context beyond destructiveHint annotation. Mentions quote ID expiration. Could be improved by describing expected response (e.g., booking ID) but still strong.

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

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

Three sentences, no wasted words. First sentence front-loads purpose, second explains structure, third covers payment and auth. Efficient and clear.

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?

Good for selection and basic invocation, but lacks mention of response format (e.g., booking ID or confirmation). With no output schema and nested complexity, some guidance on return value 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?

Adds significant meaning beyond 100% schema coverage, e.g., 'one leg per pickup→delivery pair', 'minimum 2 legs', 'quote IDs expire and rotate', and 'stop_index referencing quoted sequence'. Enhances understanding of how to fill parameters.

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

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

The description clearly states it books a multi-stop FTL route quoted by multistop_quote, with specific verb 'Book' and resource, and distinguishes from siblings like 'book' (single stop) and 'batch_book'.

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?

Explicitly indicates prerequisite (use after multistop_quote) and payment behavior (no card charge, account settlement). Implicitly differentiates from single-stop booking via sibling names, but lacks explicit 'when not to use' or alternative guidance.

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

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

Annotations already indicate readOnlyHint=true, and the description adds context about route ordering, authentication requirements, and coverage limitations. No contradictions detected.

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

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

Three sentences cover purpose, use cases, alternative, and caveats. No redundancy; every sentence 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?

Lacks output schema but describes the tool's behavior, scope, and limitations well. Outperforms a bare-bones description but could mention return format or error scenarios.

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 schema already details each parameter. The description provides no additional parameter-level meaning beyond what's in the schema, meriting a baseline score.

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 defines the tool as quoting a multi-stop FTL route with a specific order (first pickup → intermediate stops → final delivery). It distinguishes itself from the sibling tool 'ftl_quote' by contrasting multi-stop vs simple A→B.

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?

Explicitly states when to use (milk runs, pool distribution, multi-store replenishment) and when not to (simple A→B, use ftl_quote). Also notes authentication requirement and coverage dependency.

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

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

Annotations already declare readOnlyHint=true, and the description adds that it returns has_card and onboard_url if needed. No contradictions. 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?

Two efficient sentences that front-load the purpose and usage. No wasted 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 zero-parameter read-only tool, the description covers purpose, when to use, and return value. No output schema 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?

No parameters, so no additional information needed. Baseline 4 for 100% schema coverage.

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

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

The description clearly states the verb 'Check' and the resource 'payment method on file'. It distinguishes itself from sibling tools by being the only payment-specific 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?

Explicitly says when to use: 'if user asks about payment status' or 'before booking to confirm can book'. While it doesn't state when not to use, the context is clear and no alternatives exist among 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?

The description adds that authentication is required, going beyond the readOnlyHint annotation. However, it does not disclose other behavioral traits like pagination, rate limits, or how 'recent' is defined. With annotations already indicating a safe read operation, the description provides minimal additional 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 concise—two sentences front-loaded with purpose and usage. Every sentence provides essential information without redundancy or wordiness, making it easy for an agent to parse quickly.

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

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

For a parameterless list tool, the description covers purpose, scope, and authentication. It could clarify what 'recent' means (e.g., time range) or whether results are ordered, but given the simplicity of the tool, the description is largely complete and sufficient.

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

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

The input schema has zero parameters and 100% schema coverage, so the baseline is 3. The description does not add parameter-level details because there are none. It could have set expectations for the output format, but the dimension focuses on parameters, so the score remains at baseline.

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 'recent freight quotes', specifying the modes (LTL, van, box truck, FTL) and scope 'from all sessions'. This effectively distinguishes it from sibling tools that create individual quotes or fetch specific details.

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

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

The description provides a clear use case ('surfacing prior pricing on similar lanes'), which guides when to use this tool. While it does not explicitly list alternatives or when not to use it, the context implies it is for historical review rather than new quotes or bookings.

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

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

Annotations already indicate not read-only and not destructive. Description adds 'Auth required' which provides some behavioral context, but does not disclose whether saving overwrites existing templates, error behavior, or other side effects.

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

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

Description is a single sentence plus an auth note, front-loading the key action and purpose with no wasted words. Highly concise.

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?

Tool has 9 parameters, no output schema, and no behavior beyond creation described. Description explains purpose and auth but omits success/error responses, uniqueness constraints, or update behavior. Adequate but incomplete for complex usage.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. Description adds no additional semantics beyond what is in the schema, achieving baseline value.

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

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

Description clearly states verb 'Save', resource 'reusable load template (a named shipment config)', and purpose 'so it can be recalled for repeat lanes'. Distinguishes from siblings like delete_load_template and load_templates.

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?

Description mentions 'Auth required' but provides no explicit guidance on when to use this tool versus alternatives like load_templates or delete_load_template. Usage context is implied but not differentiated.

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

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

Beyond the annotations, the description discloses merge-partial update semantics, allowlisted keys, null behavior for clearing, server-side derivation of spend, the 180-day excluding-cancelled population, and auth requirements. It also adds the crucial safety framing that the profile never authorizes anything. This is rich behavioral context beyond what idempotentHint and destructiveHint already convey.

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 dense and long, but every sentence adds operational value: scope, computation method, comparison to a sibling, usage directive, update semantics, and safety warning. It is front-loaded with the read purpose and does not waste words on filler; a slight trim of the enumerated examples could improve it, but the structure 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?

For a tool that both reads and mutates, the description covers the read output composition, the update behavior, the difference from list_bookings, the no-permission caveat, and auth. Since there is no output schema, it would be stronger if it stated what set_preferences returns after an update, but overall the description supplies enough context for correct invocation.

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

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

Schema coverage is 100% and the schema already documents each field and the omit-to-read behavior. The description adds meaningful semantics not visible in the schema: set_preferences is a merge-partial update, only allowlisted keys are accepted, and null clears a key. That goes beyond the baseline, though the nested field meanings are mostly carried by 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 names a specific action ('Read how this account actually ships') and enumerates what it returns: lanes, counts, pallet dims, spend, and owner-set preferences. It explicitly contrasts its booking-count population with list_bookings, so an agent can distinguish it from that sibling. The dual read/update behavior is described precisely rather than left to inference.

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

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

The description gives a concrete directive: read this before asking the user questions it already answers, then lists example pre-fills. It says when to pass set_preferences versus omit it, clarifies that the profile is context never permission, and points to spend policy for limits. It also distinguishes its narrower population from list_bookings, which tells the agent when another tool is 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?

Annotations already indicate readOnlyHint=true. The description adds that it validates API keys, which is useful behavioral context beyond what annotations provide.

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 purpose, no wasted words. Every sentence contributes 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 simple tool with no parameters and no output schema, the description is adequate. It covers the main functions, though return format is not described.

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?

No parameters exist, so the baseline is 4. The description correctly identifies the lack of input requirements.

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 checks Warp API health and version, and validates API key. This is specific and distinct from sibling tools like booking or quote 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?

No explicit when-to-use or alternatives are mentioned. Usage is implied from the tool's nature as a health check, but no guidance is provided.

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

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

Annotations already declare readOnlyHint=true, so the description does not need to reiterate that. It adds 'Auth required', which is useful, but does not disclose what the tool returns or other behavioral aspects like real-time nature.

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

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

Two sentences with no wasted words. The key information is front-loaded: action, resource, and identifier types.

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

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

No output schema is present, and the description does not explain what the tool returns (e.g., tracking status, location, timestamps). With many sibling tools related to shipments, more context on the output 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 coverage is 100% with a descriptive parameter including an example. The description adds little beyond the schema ('by ID or tracking number' mirrors the parameter description). Baseline 3 is appropriate.

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

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

Description clearly states the verb 'Track' and the resource 'shipment', and specifies the identifier types (ID or tracking number). This distinguishes it from sibling tools like booking or quoting, which serve different 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 mentions 'Auth required' but does not provide explicit guidance on when to use this tool versus alternatives (e.g., status, events). Usage context is implied but not elaborated.

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

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

Annotations declare readOnlyHint=true, so the safety profile is covered. The description adds 'firm price' and the 1-3 pallet scope, which are useful behavioral details, but does not explain what happens outside those bounds or describe the quote's return characteristics.

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 communicates the core action and key constraints immediately.

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

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

With 11 parameters fully documented in the schema and readOnlyHint covering safety, the description is minimally adequate. However, for a quote tool with no output schema, it does not clarify return format or how it relates to other quote modes, leaving some contextual 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 100%, so the schema already documents all 11 parameters. The description only mentions the pallet range, which is already defined in the schema, so it adds no meaningful parameter semantics beyond what is structured.

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

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

States a specific verb ('Quote') and resource ('cargo van shipment'), and adds scope ('1-3 pallets, firm price'). It distinguishes the tool from other quote siblings by mode, but does not explicitly name or contrast them.

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

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

The description implies usage for cargo van shipments of 1-3 pallets, but offers no explicit when-to-use guidance or mention of alternative quote tools (e.g., ltl_quote, ftl_quote). An agent must infer the appropriate context from the mode name and constraints.

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