WebRef (paid)

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

With no annotations, the description carries the full burden. It usefully discloses pricing ($0.003 per call) and the core output behavior (it tells you what to send instead on a mismatch), which implies a read-only, side-effect-free advisory tool. However, it does not explicitly state that no state is modified or detail the response shape.

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 tight sentences, front-loaded with the core behavior and followed by the mismatch case and cost. Nothing is wasted or buried.

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 two-parameter, pure-computation advisory tool with full schema coverage and no output schema, the definition covers purpose, mismatch handling, and cost. It is nearly complete; only an explicit note on statelessness/output shape would close the remaining gap.

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

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

Schema description coverage is 100%, so both parameters and the endpointKind enum are fully documented in the schema. The description echoes their meaning but adds no format or edge-case detail beyond what the schema already provides — baseline 3.

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: it checks a Content-Type header against an endpoint kind and recommends a replacement. That clearly separates it from the surrounding advice/list siblings, though it never names them explicitly to disambiguate.

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 only implied — an agent can infer you call it when you have a Content-Type and an endpoint kind to validate. There is no explicit when/when-not, no prerequisites, and no pointer to alternatives such as mime_type or list_mime_types.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose two non-obvious traits: the exact information returned and a per-call cost ($0.003), which is genuinely useful for an agent budgeting calls. It leaves unstated what happens for an unrecognized method string and does not explicitly frame the operation as read-only, so it falls short of full 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?

One front-loaded sentence that names the resource first and then the four returned attributes, with the cost note in a compact parenthetical. 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?

There is no output schema and no annotations, so the description must convey the return content and safety profile itself — it lists the four returned facts and a lookup verb implies a non-mutating read, plus it covers pricing. Only edge-case behavior (invalid/unknown method input) is 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?

There is a single parameter with 100% schema description coverage ('e.g. GET, POST, PATCH'), so the schema already documents it. The description adds no format details such as case sensitivity or whether arbitrary/extension method tokens are accepted, so the baseline 3 applies.

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

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

Specific verb (describe) plus specific resource (HTTP method), and it enumerates exactly what the answer covers: safety, idempotency, body presence, and intended use. That makes it trivially distinguishable from siblings like http_status or content_type_advice, which address different HTTP concepts.

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 by the purpose — an agent calls this when it needs semantics for a given HTTP method — but the description never states when to prefer it over siblings such as retry_advice or status_for_situation, nor any exclusions. It is minimum-viable routing information rather than explicit guidance.

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

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

With no annotations, the description carries the full burden, and it does reasonably well: it discloses the returned facets and adds non-obvious cost context ("$0.003 per call"). It does not state that the lookup is read-only or what happens for unknown/non-standard codes, which is the main remaining gap.

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 a tight colon-separated list; the resource is named first and the payoff is immediate. The enumerative list is slightly long but each item corresponds to a distinct return field, so little is wasted.

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?

There is no output schema, so the description must convey the return surface — and it does, enumerating the answer components (meaning, client action, retryable, replay-safe, RFC, causes). Combined with the schema's detail enum, an agent has enough to call it correctly; only edge-case behavior for invalid codes 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 description coverage is 100%, so both parameters (code, detail) are already documented in the schema, including the detail enum levels. The description adds no syntax, default behavior, or format information beyond what the schema provides, so the baseline 3 applies.

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

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

The description gives a specific verb+resource ("Look up an HTTP status code") and enumerates the exact facets returned: meaning, required client action, retryability, replay safety, RFC, and common causes. It clearly distinguishes the tool from vague neighbors, though it never names the closest siblings (retry_advice, status_for_situation) to explain how it differs.

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 only implied — "look up an HTTP status code" makes the trigger obvious, but there is no explicit when-to-use, when-not-to-use, or alternative routing. A sibling like status_for_situation or retry_advice overlaps in domain, and the description gives no guidance on when to pick this tool instead.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose a real behavioral trait beyond the schema: the $0.003 per-call cost. However, it says nothing about read-only safety, result size, or how the default limit of 50 affects enumeration, leaving meaningful gaps for a no-annotation tool.

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

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

A single tight sentence with the core capability front-loaded and the cost appended cleanly at the end. The 'anything to do with calendars' example is slightly loose but earns its place by illustrating keyword search.

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 3-parameter list tool with no annotations and no output schema, the description covers the search semantics but omits the limit/pagination parameter and any indication of result shape or ordering. Adequate to invoke, but not complete.

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

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

Schema description coverage is only 33% — only 'topLevel' is documented in the schema. The description partially compensates by naming the two filtering modes (top-level type, keyword), which map to 'topLevel' and 'query', but 'limit' and pagination behavior are undocumented in both places.

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

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

The description names a specific verb and resource ('List or search MIME types') and scopes it to two filtering modes, top-level type or keyword. It does not, however, distinguish itself from the sibling tool 'mime_type', which an agent could easily confuse with this one.

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 through concrete examples ('image types or anything to do with calendars'), which helps an agent recognize the intended search patterns. But there is no when-not guidance and no routing to the 'mime_type' sibling, so the agent must guess which MIME-related tool to pick.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the return content (top-level type, purpose, usual extension) and the per-call cost of $0.003, which is genuinely valuable context, but says nothing about error behavior for unknown types, auth requirements, or what happens when both parameters are supplied.

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

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

A single front-loaded sentence covers verb, both input modes, and return fields, with the cost parenthetical appended compactly. Every clause earns its place with zero padding.

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-optional-parameter lookup with no output schema, the description covers inputs and return fields adequately. However, with zero required parameters it never explains what the tool does when called with no arguments or with both arguments, which is a meaningful ambiguity 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?

Schema description coverage is 100% and both parameters are documented with examples in the schema itself, so the baseline is 3. The description adds only a restatement of the two lookup modes and no precedence or combination rules beyond what the schema already says.

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 ('look up') and resource ('MIME type'), and names the two lookup modes (full type or file extension) plus the returned fields. It does not explicitly contrast itself with the sibling list_mime_types, though the singular lookup framing implies the distinction.

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

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

The two accepted lookup modes are implied usage guidance, but there is no explicit when-to-use statement, no condition for choosing between type and extension, and no reference to the obvious alternative list_mime_types for bulk retrieval.

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

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

With no annotations, the description carries the disclosure burden and does well: it states the three possible decision outcomes, mentions a suggested backoff schedule, and discloses the per-call cost. It does not explicitly say the tool is side-effect-free or describe the response shape in detail, but the advisory nature is clear.

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 wasted words: it states the decision, lists the three outcomes, notes the backoff schedule, and includes the price. Every clause adds useful information.

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

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

For a simple two-parameter advisory tool with no output schema, the description gives enough: it explains the decision categories and that a backoff schedule is included. The main gap is not explaining how the idempotent input influences the recommendation, though the schema does define that parameter.

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 50%; the description clarifies that 'code' is a status code, but the 'idempotent' parameter is only documented in the schema. The description does not explain how idempotency changes the advice, which is central to interpreting that parameter.

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: decide how a client should react to a status code, with three named reaction types. It is clear, but it does not explicitly distinguish itself from siblings like http_status or status_for_situation, which also concern status codes.

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

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

The phrase 'Decide how a client should react to a status code' implies the use case, but there is no explicit when-to-use guidance, no when-not guidance, and no named alternative tools. An agent can infer the context but must reason about sibling selection on its own.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses a behavioral trait annotations would never cover — the $0.005 per call cost — but says nothing about how deterministic the answer is or whether it may return multiple candidates.

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

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

One front-loaded sentence plus examples and a cost note, with no filler. The primary purpose leads and every clause earns its place.

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

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

For a one-parameter lookup with no output schema, the description adequately signals that the return value is a status code, and it discloses cost. It could still say whether the result is a single code or a ranked set, which is the one remaining gap.

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

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

Schema coverage is 100% and the single parameter is documented as 'free text describing what went wrong.' The description goes beyond that by supplying worked examples ('the caller is being rate limited', 'upstream returned garbage') that show the expected phrasing, which genuinely helps formulate the input.

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 (Find) and resource (HTTP status code) plus a precise scope qualifier: 'when the code is not known in advance.' That scope clause implicitly separates it from siblings like http_status (code-first lookup), so an agent can route correctly 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?

Gives a clear condition for use ('when the code is not known in advance') and two concrete triggering examples ('rate limited', 'upstream returned garbage'). It stops short of naming the complementary sibling (e.g. http_status) or stating when not to use it, but the context is unambiguous.

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