Last Price

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

The description adds real context beyond the annotations: the invoked tool may be one this connection does not expose, and effects are whatever the target tool declares rather than the conservative destructiveHint=true on the dispatcher itself. It stops short of describing failure behavior for an unknown name or whether the target's output is passed through unchanged.

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 short sentences, front-loaded with what the tool does, then the naming prerequisite, then the behavior caveat. Nothing is padded or repeated.

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 dynamic dispatcher with arbitrary nested arguments this covers the essentials: how to obtain the name, how to shape arguments, and that semantics belong to the target tool; an output schema exists so return values need no explanation. The remaining gap is error handling for an unresolvable tool name.

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 both properties are self-documenting, so the baseline is 3. The description reinforces where the name and argument shape come from (search_tools), but adds no detail beyond what the schema's "as its input schema from search_tools describes" already conveys.

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?

"Run any Last Price tool by name, including one this connection does not list" gives a specific verb (run) and resource (a named tool), plus the non-obvious scope that unlisted tools are reachable. It also implicitly separates this from the sibling search_tools, which only finds names.

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?

"Find the name and its arguments with search_tools first" is an explicit prerequisite that routes the agent to the sibling before calling. It does not say when to call a listed tool directly instead of going through this dispatcher, so the boundary against the other siblings is only implied.

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

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

Beyond the annotations, the description explains charging semantics: nothing is charged until payment is sent, idempotency_key enables safe retry after ambiguous errors, valid_until limits how long a result holds, and missing inputs produce a named error. These details materially help an agent invoke a non-read-only, non-idempotent tool safely.

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 purpose and return summary are front-loaded, followed by conditional guidance. It is a dense single paragraph, but nearly every sentence carries distinct invocation or behavioral information relevant to this complex 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 27-parameter tool with an output schema, the description covers the main pricing modes, error behavior, payment flow, result validity, and confidence/price_statement semantics. The remaining parameter details are well handled by the schema and 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 description coverage is already 100%, so the baseline is 3. The description adds meaningful relationships among unit_cost, current_price, target_margin_pct, competitor metadata, and payment, and clarifies confidence and price_statement beyond field-level definitions.

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

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

The description states a specific verb and resource ('Compute a price') and enumerates the returned values, so the core purpose is clear. It does not explicitly distinguish this from sibling tools such as verify_price or pricing_conversation, so sibling differentiation is missing.

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 clear invocation context: send currency with unit_cost or current_price, use metadata for competitor offers, omit payment to read the price, and expect missing inputs to error. It lacks explicit when-not-to-use guidance or direct comparison to sibling pricing tools, but the operating context is well established.

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 readOnly/idempotent/non-destructive, so the bar is lower, but the description still adds real behavior: receipts are generated on demand rather than continuously, the credential needs price compute or billing read scope, and a self-registered sandbox key is refused with 403 until the workspace is claimed. That last point is exactly the kind of failure mode 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 purpose, then key semantics, then the REST alternative, then prerequisites — a logical order with no filler sentences. It runs slightly long because it enumerates return fields ('what was priced, by which function and agent, when, the amount, how it was paid...') that an output schema already covers.

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

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

For a one-parameter read tool with full schema coverage, annotations, and an output schema, this covers everything an agent needs: how to obtain the id, what comes back, an alternative for other formats, and both auth/workspace preconditions including the 403 case.

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 is already documented, so baseline is high; the description still adds meaning by identifying the id as the same one returned by list_usage_events and accepted by report_outcome, which clarifies provenance and reuse beyond the schema's own wording.

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 ('Get the receipt for one of your workspace's priced calls') and pins the exact lookup key, distinguishing it from list-style siblings. It also cross-references the tools that produce/consume the same id (list_usage_events, report_outcome), so an agent can place it in a workflow without opening a 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?

Gives explicit when-to-use (a single priced call identified by usage event id) and an explicit alternative for other needs: 'For CSV or a printable page, call GET /api/receipts/{id} with format=csv or format=html.' It also states the two prerequisites (scope and claimed workspace) that otherwise cause silent failures.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description's only addition is the tenant scoping, which largely restates openWorldHint=false; it says nothing about pagination behavior, default ordering, or result caps beyond what the schema implies.

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

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

A single front-loaded sentence with zero filler. It is efficient, though its brevity comes at the cost of any operational detail.

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

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

With five optional filter/pagination params, rich annotations, and an output schema, the description does the minimum: it identifies the resource and tenant scope. It never explains that all five params are optional combinable filters or how paging should be driven, leaving that entirely to the schema.

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

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

Schema description coverage is 100% with well-documented limit/offset/status/is_builtin/execution_type fields, so the baseline of 3 applies. The description adds no filtering or pagination semantics beyond what the schema already states.

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?

Clear verb+resource ("List the pricing functions") with a useful scope qualifier ("registered for the authenticated tenant"). No sibling tool overlaps with function listing, so explicit differentiation is unnecessary, though the description never says what a 'pricing function' is relative to the compute_price/verify_price siblings.

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

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

No when-to-use guidance, no mention of when to prefer get-by-id or compute_price instead, and no hint that results are paginated or filtered via the optional params. The usage context is only inferable from the name.

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

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

The description adds substantial behavioral context beyond the annotations: prepare is free and does not compute, compute uses the authenticated pricing API, credentials must be configured, and continuation must not be treated as authorization. It also explicitly forbids inventing answers.

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 purpose and then explains the prepare/compute flow, credential prerequisite, and safety rule. It is dense but mostly efficient, with minor awkwardness from phrases such as 'return its questions to the caller.'

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 complex tool with nested request objects, an output schema, and workflow actions, the description covers the essential preparation, computation, authentication, and safety behavior. It could be stronger by explicitly relating this tool to sibling pricing tools.

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

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

With 100% schema description coverage, the schema already documents the parameters well. The description still adds useful workflow meaning for action, request reuse via continuation.request, and answers to the questions asked by the previous call.

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

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

The description clearly states that this tool asks Last Price which pricing inputs are missing and supports prepare versus compute actions. It does not explicitly distinguish the tool from sibling tools such as compute_price or verify_price, so it is clear but lacks sibling differentiation.

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

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

It gives concrete usage steps: start with request {}, return questions, then send continuation.request and answers, and only use compute when ready. It also states that prepare is free and that a credential must be configured first, though it does not name sibling alternatives.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=false), the description discloses that the API key is shown once, that a claim link is returned, that daily limits are provided, and how credential propagation differs on hosted vs external MCP. These are important behavioral details for a setup/authentication tool.

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

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

The description is front-loaded and dense, covering creation, output, credential behavior, and parameters in a few sentences. It has some redundancy, e.g. 'no key and no human' is repeated at the end as 'needs no credential', and the name constraints duplicate the schema.

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

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

For a registration tool with no output schema, the description is complete: it explains what is created, what values are returned, how the credential is used afterward, and the parameter expectations. Nothing essential for invoking it correctly is missing.

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

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

Schema coverage is 100%, so all three parameters are already documented in the input schema. The description repeats the name length/character constraints and notes that contact_email and intended_use are optional, but adds little meaning beyond the schema.

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

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

The description states a specific verb and resource: 'creates a sandbox workspace of your own and returns its API key'. It distinguishes this from credential-requiring siblings by saying it needs 'no key and no human', and names the concrete outputs (key, daily limits, claim link).

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 explains that the tool is public and needs no credential, and that on the hosted MCP server the session continues using the new key while elsewhere the key must be sent as x-api-key. That is clear context, but it never explicitly says when to prefer this over a credential-bearing flow such as use_api_key.

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 it discloses statelessness of the hosted endpoint ('remembers nothing, so pass it there'), single-shot semantics for the fallback path, the refund mechanic for rejections inside the outcome window, the required Last Price credential, and the 403 refusal for unclaimed sandbox keys. That is substantial behavioral context the annotations do not carry.

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?

Purpose is front-loaded in the first clause and the parentheticals are compact, though the single dense paragraph mixes reporting rules, billing mechanics, and auth constraints. The line 'Report only what actually happened' is the one sentence that adds little.

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

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

For a non-idempotent write with an output schema, the description covers everything an agent needs before calling: trigger condition, id resolution, credential and workspace prerequisites, and the consequence of rejection. Return values are delegated to the output schema appropriately.

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

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

Schema coverage is 100%, so the baseline is 3, but the description still adds real meaning for usage_event_id by explaining that omission resolves to the last compute_price result and that this only works once and not on the hosted endpoint. Other parameters (evidence fields, quality_score) are left to 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 opens with a specific verb + resource ('Report whether a price from compute_price was used') and ties the tool to the exact upstream call that produces its input, so an agent can tell it apart from verify_price or get_receipt without opening the schema.

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

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

It states the triggering condition clearly ('once the buyer has accepted or turned down a price, report it') and explains the omitted-parameter path versus passing a specific receipt id. No sibling alternative is named as a when-not, which keeps it 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?

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds genuinely non-obvious behavioral context: the result set includes full input schemas for the matched tools, and an empty query returns every tool name rather than an error. It notes the 300+ tool breadth of the server, which is 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?

The core guidance is front-loaded, but the parenthetical catalog enumeration ("pricing functions, routing, experiments, webhooks, billing, orders, the marketplace and more") is padding that does not help an agent act. The opening "Find the Last Price tool" phrasing is confusing and costs the reader a pass before the real purpose lands.

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

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

An output schema exists, so return-shape explanation is unnecessary, and the description still covers the essential next step after results arrive. For a two-parameter discovery tool this is nearly complete, with only the `limit` behavior and any ordering/ranking semantics left unaddressed.

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

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

Schema coverage is 100%, so both parameters are already documented, giving a baseline of 3. The description adds the meaningful empty-query semantics for `query` (lists all tool names) but says nothing about `limit` beyond what the schema contains, so it adds only partial value.

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

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

The description states a specific action and resource: find/list tools matching a task query, and it explicitly distinguishes itself from the rest of the catalog by noting that this connection only exposes price-reaching tools while the server hosts 300+ others. The opening phrase "Find the Last Price tool for a task" is awkward and slightly obscure, which keeps it from a 5, but the intended purpose (tool discovery) is unambiguous by the second sentence.

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

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

It clearly frames the workflow: pass a few words, get matching tools with full input schemas, then invoke one via call_tool or by name. The no-query behavior is explicitly described, so an agent knows both the normal and the fallback path. It stops short of stating when not to use it (e.g., when the target tool is already known or is a visible sibling), so it is not a full 5.

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

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

Goes well beyond the annotations: discloses that the key becomes the session's identity, that the effect is session-scoped and ends on session end/revocation/rotation, that the key is validated but never echoed, and that existing credentials take precedence. That is exactly the lifecycle and side-effect information an agent needs for a stateful auth operation with destructiveHint=false but readOnlyHint=false.

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

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

Compact and front-loaded — the precondition and the action come first, then consequences, then the security note. The first sentence is an awkward colon-spliced run-on, but no sentence is filler.

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

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

For a single required parameter with full schema coverage and no output schema, the description covers scope, duration, and credential precedence, which is what an agent needs to decide and act. It does not say what happens on an invalid or revoked key at call time, a minor gap given the schema pattern already screens format.

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 already specifies the lp_ + 40-hex pattern, so the baseline is 3. The description adds real value by telling the agent where the value comes from (a saved file or LASTPRICE_API_KEY env var the caller already holds), which the schema does not say.

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 action — authenticating the current MCP session with a Last Price API key the caller already holds — and names the concrete condition (connection was opened without one). No sibling tool in the list does anything comparable, so there is no ambiguity to resolve.

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 both the trigger (session opened without a credential) and the exclusion (a connection that already has a credential keeps it, so this call is unnecessary). It also notes the endpoint is public and needs no other credential, removing a common precondition question.

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 the verdict values, what unknown means, how next_step should be interpreted, quote-expiry behavior, x402 payment behavior, and that unknown verdicts are not charged. These are meaningful behavioral details for a tool whose annotations mark it as non-read-only and open-world.

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 front-loads the purpose, return values, and next-step guidance, and most sentences carry useful information. It is longer than typical because the tool has complex payment and verification modes, but the single-paragraph structure makes it somewhat harder to scan.

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

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

Given the tool's complexity, 16 parameters, and rich output schema, the description covers the critical behavioral context: verdict semantics, next steps, quote expiry, payment, and buyer-budget evidence. It does not need to explain return values in full because an output schema exists.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds useful meaning for key parameters such as proposed_price being the subject, quote_valid_until coming from compute_price, payment using x402, and metadata.category triggering buyer_budget evidence. It does not need to restate every schema-described field.

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

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

The description states a specific verb and resource: verifying whether a price makes sense for its context. It explicitly contrasts this with computing what the price should be, which distinguishes it from the sibling compute_price tool.

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

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

The opening sentence tells the caller when to use this tool versus compute_price, and later text explains the workflow by saying to pass quote_valid_until from the compute_price result. It also gives concrete guidance on acting on next_step values and when a paid verdict applies.

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