DERATE — truck fault codes

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

Annotations already cover the safety profile (readOnly, idempotent, closed-world), so the description's value is in disclosing the response contract: severity, derates yes/no, meaning, part, price range, and page URL. That is genuinely useful behavioral context beyond the annotations, though nothing is said about rate limits or result count limits.

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 verb and library scope, then the return contract. The trailing Spanish sentence largely restates the English rather than adding information, but given the bilingual tool it is a minor cost.

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 exists, so the description correctly compensates by naming the returned fields. What it omits is routing guidance: with a near-identical sibling (search_fault_code_library) and related lookup tools, the description does not give an agent enough to choose correctly.

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

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

Schema description coverage is 100%, so both params are already documented. The description restates the query modes ('SPN/FMI, P-code or free text') matching the schema, and adds nothing about the lang switch beyond the schema enum. 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?

States a specific verb (Search) and resource (DERATE's 56-code heavy-truck library) with matching modes (SPN/FMI, P-code, free text). However it never differentiates itself from the sibling search_fault_code_library, which appears to overlap heavily, so an agent cannot tell them apart from the description alone.

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

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

No when-to-use guidance, no prerequisites, no indication of when to prefer this over search_fault_code_library or list_fault_codes. The bilingual framing implies it is the entry point for es/en lookups, but that is left to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, and closed-world (openWorldHint=false); the description reinforces the closed-world scope ('library only') and adds a genuinely useful behavioral detail: unrecognized codes return 'unknown' rather than erroring. It does not describe latency, rate limits, or response fields beyond the verdict, so it stops short of full disclosure.

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 verdict and its possible values; every clause carries signal. The Spanish half is a translation that adds little for an agent, a minor redundancy in an otherwise lean definition.

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 compensates by naming the full verdict domain (stop / service_soon / info) plus the 'unknown' case, and annotations cover the safety profile. For a two-parameter read tool this is close to complete; only the broader response shape (e.g., accompanying message or code echo) is left unstated.

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%: the 'code' parameter documents accepted formats ('SPN 3251 FMI 0', '3251/0', 'P20EE') and 'lang' documents its enum and default. The description adds no parameter-level meaning, 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?

States a specific verb+resource (returns a safe-to-drive verdict for a truck fault code) and enumerates the output domain (stop / service_soon / info). It scopes itself with 'from DERATE's library only' and notes the 'unknown' fallback, which implicitly separates it from library-lookup siblings, though no sibling is named directly.

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 tool for a safety verdict on a code, and the 'DERATE's library only' + 'unknown' behavior sets a boundary. There is no explicit when-to-use guidance or routing to alternatives such as explain_fault_code, get_diagnosis, or interpret_derate.

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 and closed-world, so the safety profile is covered. The description adds genuine behavioral context by enumerating what the response contains (severity, probable causes, tests with expected values, repair steps, cost estimate), which substitutes well for the absent output schema. It stops short of stating auth, rate limits, or unknown-code 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 front-loaded sentence with no filler; the verb+resource leads and the response contract follows. The trailing list is long but each item is informative rather than redundant.

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 usefully enumerates the returned fields, and read-only behavior is covered by annotations. The one meaningful gap is routing guidance against the many similar siblings, which leaves the agent guessing between this and interpret_derate or get_truck_fault_code.

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 the 'query' and 'lang' parameters are already fully documented in the schema with examples and an enum. The description adds no format or syntax detail beyond what the schema provides, making the baseline 3 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?

States a specific verb (explain) and resource (truck fault code or symptom) and scopes the response to DERATE terms. However, it does not distinguish itself from close siblings such as get_truck_fault_code, interpret_derate, or get_diagnosis, so an agent cannot tell them apart without opening the 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?

The description gives no when-to-use or when-not-to-use guidance and never names alternatives, despite a crowded sibling set that includes list_fault_codes, search_fault_code_library, get_truck_fault_code and interpret_derate. Usage is only inferable from the verb 'explain'.

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 and openWorldHint=false, so the safe, deterministic, local read profile is covered. The description adds licensing (CC BY 4.0) and citation guidance, which is genuinely beyond the annotations, but says nothing about response shape, freshness, or size of the notes payload.

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 compact sentences that lead with the resource and then the payload contents; nothing is padded. The English/Spanish duplication is arguably redundant, but it mirrors the tool's own lang parameter and is therefore defensible.

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 carries the burden of telling the agent what comes back, and it does so item by item (counts, sources, gaps, license, citation, URLs). For a zero-required-parameter metadata tool this is close to sufficient; permissions and pagination are simply not relevant here.

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 the single 'lang' parameter is fully documented in the schema with an enum and default, so the baseline of 3 applies. The bilingual wording of the description hints at language support but adds no syntax or default information 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 names a specific resource — DERATE dataset notes — and enumerates its contents (code count, sources, known gaps, license, citation, download URLs), which separates it from siblings like list_fault_codes or interpret_derate that operate on individual codes. It stops short of explicitly contrasting itself with overlapping siblings such as get_download_links or get_pricing.

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

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

There is no when-to-use or when-not-to-use guidance, and no alternative is named. The agent must infer from the content list that this is a metadata/licensing lookup, and must guess the boundary with get_download_links, which also covers downloads.

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 and openWorldHint=false, so the safety profile is covered. Because there is no output schema, the description's disclosure of the actual response contents (verdict values, countdown, fault codes, work order summary) is the only place that information exists and adds real value; only auth/rate-limit context is absent.

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 front-loads the verb and scope and spends every clause on distinct return content. No filler or restatement of the title.

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

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

With no output schema, the description carries the return-value burden and does so well, including the verdict vocabulary. It is slightly incomplete in not clarifying how a truck is identified when zero parameters are required, and in not hinting that output language follows 'lang'.

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

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

One optional parameter with 100% schema description coverage, so the schema fully documents 'lang' with its enum and default. The description adds nothing about language selection, 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?

States a specific verb ('Return') and resource ('full DERATE demo diagnosis for a truck') and enumerates the payload (verdict, countdown, fault codes, work order summary). That enumeration differentiates it from narrower siblings like interpret_derate or get_truck_fault_code, though no sibling is named explicitly.

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

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

There is no when-to-use guidance and no routing against the many overlapping siblings (interpret_derate, explain_fault_code, get_truck_fault_code, es_seguro_manejar). An agent must infer that this is the aggregate 'everything at once' call purely from the return-field list.

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, openWorldHint=false, and idempotentHint=true, so the safety profile is covered. The description adds the useful constraint that DERATE is mobile-only, which explains why the tool exists. Beyond that, it adds little behavioral context.

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

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

Two short sentences, front-loaded with the outcome (official links) and followed by a clarifying scope constraint. No 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?

A zero-param, no-output-schema utility tool with annotations covering the key behavior. The description states what is returned and the mobile-only constraint, which is sufficient. Slightly short of a 5 only because return format is left implicit.

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?

Zero parameters, so per the rubric baseline is 4. The description adds no parameter information, which is correct since there are none.

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 (Return) and resource (App Store and Google Play links for the DERATE native app). No sibling could be confused with it; it's the only link-distribution tool in the set.

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?

Implies when-to-use by noting DERATE runs only as a mobile app, but gives no explicit conditions or alternatives. Sibling tools exist for diagnosis/fault codes, not links, so the routing is obvious by default, but no explicit guidance is offered.

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, openWorldHint=false, and idempotentHint=true, so safety is covered. The description adds useful return context: full markdown text, sources, and a citable derate.app URL. It does not mention auth or rate limits, but for a read-only lookup this 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?

Two parallel bilingual sentences with the purpose front-loaded and no waste. The bilingual format is justified and 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 simple read-only retrieval with full schema coverage and annotations covering safety, the description explains the return format (full text, sources, citation URL) sufficiently for correct invocation. No output schema means the description appropriately carries that return-value context.

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

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

Schema description coverage is 100%, with clear descriptions for both slug and lang. The description only reinforces that retrieval is 'by slug' and does not add 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 resource ('one DERATE guide or news article') and retrieval mode ('by slug'), and the phrase 'one ... by slug' distinguishes it from list/search siblings. However, it does not explicitly name the alternative tool (search_guides) for 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?

The phrase 'by slug' implies a precondition, but there is no explicit when-to-use guidance or mention of the sibling search_guides for finding slugs. Usage is therefore implied rather than 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, idempotentHint, and openWorldHint false. The description adds valuable context beyond annotations by clarifying that the app is a free download, plans are purchased in-app via app stores, and trial details for certain plans, helping the agent understand the tool does not process purchases.

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 with the core purpose front-loaded, followed by relevant context about purchase channel and free trial. Every sentence earns its place without waste.

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

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

With no output schema and no parameters, the description adequately states the return content ('plans and prices in USD') and adds helpful purchase and trial context. Slightly more detail on output structure could be useful, but the definition is complete enough for an agent to call 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?

The tool takes zero parameters, so the baseline score of 4 applies. The description correctly does not attempt to describe parameters that do not exist.

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 ('List') and resource ('DERATE's plans and prices in USD'), making the tool's function immediately clear and distinguishable from the fault-code and diagnosis 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?

The description provides useful context that purchases happen inside the iOS/Android apps, implying this tool is for informational pricing lookup, but it does not explicitly state when to use this tool versus any alternative or provide clear exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint=false, so safety is covered structurally. The description usefully adds that this is a public library requiring no account, and it enumerates the response content (meaning, severity, drive-safety, probable causes, recommended tests, canonical URL), which is non-obvious behavioral information.

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, well front-loaded with the action and resource before the return-value list. Slightly dense in the return enumeration, but every clause conveys information an agent would otherwise lack.

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 compensates by listing exactly what is returned, and it notes the no-account requirement. For a single-required-param read tool with full annotation coverage, an agent has everything needed to call it correctly; only sibling routing is missing, which is scored elsewhere.

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 'code', 'lang' (with enum), and 'engine_family'. The description restates the code format examples from the schema but says nothing about 'lang' or 'engine_family' semantics, so it adds no meaning beyond the schema. 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 states a specific verb and resource ('look up a diesel truck fault code') and enumerates the accepted code formats (J1939 SPN/FMI, OBD-II). It does not, however, differentiate itself from overlapping siblings such as explain_fault_code, search_fault_code_library, buscar_codigo, or es_seguro_manejar, which appear to cover the same ground.

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?

'Look up a fault code ... in DERATE's public fault-code library' implies the usage context, and 'Works without any account' hints at when it's viable (unauthenticated lookup). But it never states when to prefer this tool over explain_fault_code, buscar_codigo, or search_fault_code_library, which is a real selection risk given the crowded sibling set.

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 and openWorldHint=false, covering the safety profile. The description adds genuine behavioral context beyond that: the return contents (likely cause, urgency, immediate action, matching public fault-code pages) and the scope limit that guided diagnosis lives elsewhere.

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

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

Two sentences, front-loaded with the action and input, followed by a scope/output sentence. Efficient and mostly waste-free, though the app-positioning clause is denser than strictly necessary.

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 usefully covers what is returned, and the schema fully covers inputs while annotations cover safety. The only residual gap is explicit sibling routing between this tool and the code-based diagnostic 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?

Schema coverage is 100%, so the four parameters are already documented, making 3 the baseline. The description goes slightly beyond by embedding a concrete symptom example ('DEF light on and truck limited to 55 mph'), which communicates the expected free-text granularity for the required symptom 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?

States a specific verb and resource ('Explain a diesel truck engine derate or power-loss symptom') and names the inputs and outputs precisely. It also separates itself from the sibling diagnostic tools by positioning this as 'the free public interpretation' versus the full guided diagnosis in the DERATE app.

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 usage context: use this for a symptom described in plain language, as the free public interpretation, while tests and a work order belong in the DERATE app. It stops short of explicitly routing away from named siblings such as explain_fault_code or get_diagnosis when a code is already known.

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 and openWorldHint=false, so the safety profile is covered. The description adds that results belong to a stateful 'current DERATE diagnosis' and enumerates the returned attributes, but says nothing about pagination, limits, or what happens when no diagnosis exists.

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; the resource comes first and the returned fields are listed compactly at the end. 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?

With no output schema, the description usefully enumerates the returned attributes (severity, system, fault type, root cause) and the annotations carry the safety profile. It is nearly complete, lacking only behavior for the empty/no-diagnosis 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?

Only one optional parameter (lang) exists and schema description coverage is 100%, so the schema fully documents it including enum values and default. The description adds no extra meaning about the language parameter, so the baseline of 3 applies.

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

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

Names a specific verb and resource ('List the fault codes (SPN/FMI)') and scopes it tightly to 'the current DERATE diagnosis', which implicitly separates it from siblings like search_fault_code_library or get_truck_fault_code. No sibling is named explicitly, so it stops short of a full 5.

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

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

Usage is only implied through the phrase 'in the current DERATE diagnosis' — the agent can infer it applies when a derate diagnosis is active, but no when-to-use/when-not conditions or alternatives (e.g., searching the whole library) 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, idempotentHint and a closed-world scope, so the safety profile needs no restating. The description adds value by disclosing what the returned set actually contains (engine families plus the two supported protocol families), though it does not say how those entries are formatted.

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 front-loads the resource, then the payoff for the agent. No filler 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?

With no parameters, no output schema and annotations covering the read-only/closed-world profile, the definition is nearly self-sufficient; it names the returned content. A brief note on the shape of the returned list is the only minor omission.

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

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

The tool takes zero parameters and the schema is empty, so there is nothing for the description to clarify; the 4 baseline 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?

States a specific verb (List) and resource (diesel truck engine families and code protocols DERATE interprets), with concrete scope detail naming J1939 SPN/FMI and OBD-II. It is clearly separable from the code-lookup siblings, though it does not name any sibling tool directly.

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 an explicit trigger: use it 'before looking up a code' to check whether a given truck is covered. The condition that selects it is clear, but no alternative tools or exclusions (e.g. when to skip straight to list_fault_codes) are named.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=false, so the safety profile is covered. The description adds real context beyond that: the data is NHTSA-based and results come with per-make source links, hinting at the return shape. It still omits the 7-item cap behavior, pagination, and freshness/latency of the recall data.

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 compact, front-loaded sentences with no filler. The bilingual duplication costs a little space and the Spanish sentence is incomplete relative to the English one, but nothing 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?

For a four-parameter, all-optional lookup with no output schema, the description covers the domain and hints at source links, but it leaves the agent guessing about output format, the effect of the 7-item limit, and the relationship between the free-text query and the make filter.

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 baseline is 3. The description's make list loosely maps to the 'make' parameter, but it adds no syntax or precedence detail for how 'make', 'query', and 'limit' interact (e.g., whether make and free-text query conflict).

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 (check heavy-truck safety recalls, NHTSA-based) and enumerates the supported makes, which cleanly separates it from fault-code, pricing, and diagnosis siblings. The only weakness is the truncated Spanish half, which drops the per-make detail and reads as a bare label.

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 says what the tool covers but never states when to reach for it versus the many fault-code/diagnosis siblings, nor any exclusions or prerequisites. An agent gets topical context but no 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?

Annotations already declare readOnlyHint, idempotentHint, and closed-world behavior, so safety is covered. The description adds almost nothing beyond that: no pagination behavior, no relevance ranking, no hint about how partial matches behave. It does state the return shape briefly, but that is thin for a search tool with no output schema.

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

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

Two tight sentences, front-loaded with the scope and purpose. No filler. Not quite a 5 because the second sentence is doing double duty as both return description and field list, slightly compressing two jobs into one clause.

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?

Covers search scope and return fields, but with no output schema and no guidance on search semantics (fuzzy matching, case sensitivity, ranking) or pagination via limit, an agent still has gaps. The description is complete enough to call the tool but not to predict its behavior.

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

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

Schema description coverage is 100%, so parameters are already fully documented. The description adds the notion that 'query' can match code, system, dashboard light, or symptom words, which is useful beyond the schema's generic 'Code or free text to search for.' This is a modest value-add, so baseline 3 holds.

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 (full-text search), resource (DERATE's public diesel truck fault-code library), and searchable axes (code, system, dashboard light, symptom words). Distinguishes itself from siblings like list_fault_codes and get_truck_fault_code by being a free-text search rather than a lookup or list.

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?

Mentions searchable fields, which implies when this tool is useful, but does not explicitly say when to use it instead of list_fault_codes, buscar_codigo, or get_truck_fault_code. No exclusions or prerequisites are stated. Adequate but leaves routing to inference.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and openWorldHint=false, so the safety profile is covered. The description adds genuinely new context by stating the return shape (title, quick answer, derate.app URL), which matters since no output schema exists.

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 verb and resource, then the return payload, in two tight sentences. The bilingual duplicate roughly doubles length for no informational gain, though it is defensible for a lang-parameterized tool.

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

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

With no output schema, the description correctly compensates by naming what is returned (title, quick answer, URL). The remaining gap is disambiguation from get_guide, which an agent could plausibly confuse with this 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%, so both query and lang are fully documented in the schema, making 3 the baseline. The topic list ('derate, DEF, emissions, recalls, enforcement, market') loosely hints at query scope but adds no syntax or format guidance beyond the schema's own examples.

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+resource ('Search DERATE's truck-driver guides and trucking news') and enumerates the covered topics (derate, DEF, emissions, recalls, enforcement, market). It is distinguishable from fault-code siblings, but it does not clarify its relationship to the near-neighbor get_guide (search vs. fetch-a-specific-guide).

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 — search when you don't already have a specific guide or code — but the description never states when to use this instead of get_guide, explain_fault_code, or search_fault_code_library. No exclusions or prerequisites are given, so the agent must infer routing.

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