TuneWorks

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds real context beyond that: 'atomically' communicates transactional/all-or-nothing semantics, and 'without replacing its existing categories or items' guarantees additive-only behavior. No permission or rate-limit detail, hence not a 5.

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 the verb and scope first and zero filler. Every clause (atomic, additive-only, target list state) 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 an output schema present, return values need not be described, and the annotations plus the atomicity/non-replacement guarantees cover the mutation's behavioral profile for a small tool. The only real hole is the undocumented sortOrder 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 0% with 3 parameters, so the description carries the full burden. It implicitly covers listId ('existing editable shop list') and name ('one category'), but says nothing about sortOrder — its range, defaults, or ordering behavior — leaving a required parameter 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?

States a specific verb and resource ('add one category to an existing editable shop list') with enough precision to separate it from add_shop_list_item, create_shop_list, and update_shop_list. It does not name any sibling explicitly, so it falls short of the 5 benchmark.

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 precondition ('existing editable shop list') and the contrast 'without replacing its existing categories or items' imply when this is preferred over a wholesale update, but no alternative tool is named and no explicit when-not guidance is given. Usage is inferable 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 establish it is a non-destructive write (readOnlyHint=false, destructiveHint=false). The description adds real behavioral value beyond that: atomicity, additive-only semantics ('without replacing existing items'), and the side effect that a missing category is auto-created. It omits failure behavior for a non-editable or nonexistent list, keeping it short of a 5.

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 tightly written sentences, with the core action front-loaded and the side-effect disclosure second. 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?

An output schema exists, so return values need no explanation, and the annotations cover the safety profile. But with six parameters at 17% schema coverage, the description leaves most inputs undefined and says nothing about permission requirements or error behavior on a locked/missing list.

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 17%, so the description must carry the load for the undocumented parameters (label, listId, status, quantity, sortOrder) and does not. Its only parameter-adjacent content is the note about categories, which loosely maps to 'section' but never explains the field name or its relationship to the category concept.

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 ('add one item to an existing editable shop list') with scoping detail ('without replacing existing items') that separates it from update_shop_list_item and reset_shop_list_items. It does not name a sibling outright, but the additive framing makes the distinction inferable.

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 'existing editable shop list' implies the precondition that the target list must exist and be editable, which is useful. However, there is no explicit when-to-use guidance and no mention of when to prefer update_shop_list_item or add_shop_list_category 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, covering the safety profile. The description adds a genuine behavioral trait not in the annotations — that it runs without authentication or TuneWorks account data — but says nothing about return shape or constraints.

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 core action leads. It is efficient, though its brevity borders on under-specification rather than true conciseness.

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

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

For a tool with 6 parameters including a nested readings object and 17% schema coverage, the description is too thin. The output schema does relieve it of explaining return values, but the undocumented tuning thresholds and absence of usage context leave the agent under-informed.

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 17%: only "readings" is documented in the schema, while unit, targetTemp, tempWindow, rearCamberSpread, and frontCamberSpread are undocumented. The description does not compensate by explaining any of these tuning parameters, leaving 5 of 6 params without meaning.

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 clear verb ("Interprets") and resource ("inside, middle, and outside tire temperature readings"), so an agent knows the high-level function. However, it does not distinguish this from closely-related siblings like calculate_tire_pressure_adjustment or calculate_corner_balance, which also operate on tire/setup data.

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 named alternative, despite several siblings (check_race_alignment, calculate_tire_pressure_adjustment) that overlap in domain. The only contextual hint is that it works without auth, which is a capability note rather than usage direction.

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 destructiveHint=true and readOnlyHint=false, but the description adds genuinely new behavioral context: the operation is a soft archive that never hard-deletes data, and it requires explicit user confirmation. That clarifies what 'destructive' actually means here and what precondition the agent must satisfy, which annotations cannot convey.

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

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

Two short sentences, zero filler, with the core action stated first and the safety constraint immediately after. Nothing is redundant with the title or 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?

An output schema exists, so return values need no explanation, and annotations cover the safety profile. The description supplies the confirmation precondition and the soft-delete guarantee, which is close to complete for this operation; only the identifier parameters remain unexplained.

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

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

Schema description coverage is 0% across three required parameters (vehicleId, trackerId, confirmed). The description only indirectly gestures at 'confirmed' via the confirmation requirement and says nothing about what vehicleId/trackerId identify or their expected format, so it fails to compensate for the documentation gap.

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 (archive) and a specific resource (connected user maintenance item), which distinguishes it from the archive_vehicle/archive_session/archive_setup siblings by resource type. It does not explicitly contrast itself with those siblings or with update_maintenance/complete_maintenance, so it stops short of a 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?

The description implies usage (archive a maintenance item when it is no longer active) and adds one real prerequisite: explicit user confirmation. However, it never says when to prefer this over update_maintenance, complete_maintenance, or the list/delete siblings, and gives no exclusions, so guidance is 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 destructiveHint=true and readOnlyHint=false, so the mutation profile is covered. The description adds meaningful nuance beyond them: the operation 'never hard-deletes data' (soft/reversible removal) and requires explicit confirmation, which explains why the `confirmed` flag exists. It doesn't state whether an archived session can be unarchived or whether the call is idempotent.

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, zero filler, action stated first and the two behavioral caveats front-loaded immediately after. 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?

An output schema exists, so return values need no explanation here. For a low-complexity, two-parameter mutation the description covers the safety profile and the confirmation gate adequately. Minor gaps remain around reversibility/unarchive behavior and sessionId sourcing, but nothing essential to calling 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 description coverage is 0% for the two parameters. The sentence 'Requires explicit user confirmation' directly conveys the semantics of the `confirmed` flag, but `sessionId` is left entirely to the name — no indication of format, source (e.g., from list_sessions), or whether it accepts an archived session. Partial compensation for a real coverage gap.

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: 'Archive a connected user driving session.' This clearly separates it from the parallel archive_* siblings (archive_vehicle, archive_setup, archive_maintenance) by resource, and from update_session/create_session/copy_session by action. It stops short of explicitly naming which sibling to prefer under which condition, so a 4 rather than 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?

Provides one real usage constraint — that explicit user confirmation is required — which effectively tells the agent not to call this unprompted. However, it never contrasts this tool with update_session or explains when archiving is preferable to simply updating or leaving a session alone.

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 mark this as a destructive, non-read-only, closed-world mutation, and the description adds meaningful context beyond that: the operation is reversible in spirit ('never hard-deletes data') and is gated behind user confirmation. Those are exactly the traits an agent needs before invoking a destructive tool, though it does not say what happens to dependent data or whether an archive can be undone.

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 with no filler, leading with the operation and following with the two constraints that matter. 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?

An output schema exists, so return values need not be described, and the safety profile plus confirmation gate are covered. What is missing is the post-archive state: whether the setup is restorable, where it goes, or how it affects linked sessions and lists.

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

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

Schema description coverage is 0% for two required parameters, so the description must compensate: 'explicit user confirmation' maps usefully onto the `confirmed` boolean, clarifying it as genuine consent. However, `setupId` receives no explanation at all beyond the generic phrase 'connected user setup', leaving its format and source undocumented.

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 (archive) and a specific resource (all active revisions of a connected user setup), and names the scope of the operation clearly. It does not explicitly distinguish itself from nearby siblings like archive_vehicle or archive_session, but the resource is unambiguous enough that an agent can pick it out.

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

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

The description gives a prerequisite ('requires explicit user confirmation'), which is useful usage context, but says nothing about when to archive versus update or delete a setup, nor what state the setup must be in. Usage is implied rather than stated against 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is covered. The description adds the confirmation requirement and the soft-hide effect, but does not say whether archiving is reversible or what the confirming flow entails.

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, purpose and effect front-loaded, then the confirmation prerequisite. 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 an output schema present, return values need not be described, and the tool covers purpose, effect and the confirmation gate. The remaining gap is the absence of any routing guidance versus delete_shop_list.

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 'confirmed' parameter is documented in the schema while 'listId' is not. The description reinforces the confirmation requirement but adds no meaning for listId beyond the schema's type. Baseline 3 is appropriate.

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

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

The description uses a specific verb+resource ('Archive a connected user shop list') and clarifies the observable effect ('no longer appears in active lists'). However, it never distinguishes archiving from the sibling delete_shop_list, leaving the agent to infer why one would archive rather than delete.

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 a prerequisite ('Requires explicit user confirmation'), which is useful, but gives no guidance on when to choose archive over delete_shop_list or update_shop_list. Usage 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?

Annotations already flag destructiveHint=true, but the description adds real value beyond them: the deletion is a soft delete, data is never hard-deleted, and an explicit user confirmation is required first. It stops short of explaining reversibility/restore behavior or what happens to related records.

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, zero filler, with the soft-delete behavior and confirmation requirement front-loaded. Every clause carries 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?

An output schema exists so return values need not be described, and annotations cover the destructive profile. The description supplies the soft-delete and confirmation context, but omits whether the archive is reversible and how it affects dependent data such as sessions or setups.

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 0% for two parameters. The description conveys the semantics of 'confirmed' (explicit user confirmation required) but says nothing about 'vehicleId' or how the confirmation must be supplied, so it only partially compensates for the schema gap.

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 (archive) and resource (connected user vehicle) and pins down the mechanism ('TuneWorks soft-delete behavior'), which distinguishes it from a hard-delete. It does not explicitly differentiate itself from the many sibling archive_* tools, so it falls short of a 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?

'Requires explicit user confirmation' gives one clear precondition for calling it, which is genuine usage guidance. However, it never says when to archive vs. update or otherwise deactivate a vehicle, nor names any alternative sibling, so the routing guidance 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the write/impact profile is covered structurally. The description adds two pieces of non-annotated context: the record persists in history (reversibility/retention behavior) and that explicit confirmation is required. It does not state what happens to linked data, though the retention claim is arguably in mild tension with destructiveHint=true.

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 with the action and its retention outcome front-loaded and the confirmation requirement second. No filler, nothing that restates 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?

The output schema exists so return values need not be described, and annotations cover the destructive profile. However, a mutation tool with zero schema-description coverage and a confirmation flag should say what confirmation gates and whether an archived modification can be restored, which the description omits.

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

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

Schema description coverage is 0%, so the description carries the load for three required parameters. It explains the intent of 'confirmed' ('requires explicit confirmation') but says nothing about the expected format of vehicleId/modificationId or whether confirmed must be true to proceed, leaving the semantics mostly to the schema types.

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 pairing ('Mark a modification canceled') and adds the key semantic twist that it 'remains in vehicle history', which differentiates it from delete_vehicle_modification. It stops short of naming that sibling explicitly, so an agent must infer the soft-delete nature from the retention clause.

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 'so it remains in vehicle history' — use this instead of hard deletion when history must be preserved — but no alternative is named and no preconditions (ownership, permissions, archived-state idempotency) are given. It is adequate but leaves the choice between archive_vehicle_modification, delete_vehicle_modification, and update_vehicle_modification 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, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description goes beyond them by clarifying that it runs from measured inputs with no authentication and neither reads nor saves account data, plus it delimits what the estimate does not account for. Return format is left to the 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?

Four short sentences with the core action front-loaded. 'This estimates mechanical bias' partially restates the opening sentence, which is minor redundancy, but the caveat sentence earns its place.

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

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

With an output schema present, return values need not be described, and all seven required parameters are fully documented in the schema. The description covers purpose, statelessness, and the limits of the estimate, so an agent has what it needs 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?

Schema description coverage is 100% and every parameter is documented with units per unitSystem, so the schema carries the parameter semantics. The description only alludes to the input classes (piston area, rotor size, pad friction) and adds no unit or format guidance of its own, which is the expected baseline.

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

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

States a specific verb and resource ('Estimate front brake bias') and names the exact input classes (piston area, rotor size, pad friction) that drive it. This distinguishes it clearly from sibling calculators such as calculate_corner_balance or calculate_spring_wheel_rate.

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 useful framing about what the estimate represents ('mechanical bias') and warns that tire grip, weight transfer, ABS, and balance bars still matter, which helps an agent judge the result's scope. However, it never states when to pick this tool over adjacent calculators like calculate_corner_balance, nor any prerequisite ordering.

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 destructiveHint=false, so the safety profile is covered. The description adds useful context beyond them: it is a pure calculation from measured inputs, requires no authentication, and does not read or save account data, plus the domain caveat about measuring under driving conditions.

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 front-loaded sentences with no wasted wording; the outputs are named first, then the no-auth/no-persistence note, then the measurement caveat. The middle sentence overlaps somewhat with the readOnly annotations, keeping it just short of perfect.

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 values need not be explained, and the schema fully documents all inputs. For a stateless calculator the description covers purpose, safety posture, and the key measurement precondition, leaving nothing an agent needs to invoke 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?

Schema description coverage is 100%, so all five parameters (lf, rf, lr, rr, unitSystem) are already documented with units and the enum. The description only alludes to 'four scale pads', adding no syntax or meaning beyond the schema, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb ('Calculate') and the exact resources it derives: cross weight, left/right balance, and front/rear split from four scale pads. This distinguishes it from sibling calculators such as calculate_brake_bias or calculate_spring_wheel_rate without needing to open 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 gives valuable input-preparation guidance ('Measure the car in the same state you drive it: driver, fuel, ballast, and tire pressures matter'), which tells the agent how to use the tool correctly. However, it never states when to choose this tool over alternatives or any exclusions/conditions, so usage 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful context beyond annotations: no auth/account access, the 0–100 percentage domain, that volumes share the selected unit, and that source ethanol contents are measured rather than assumed.

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-loads the purpose, then adds shared constraints, then the mode-to-parameter mapping. Every sentence carries information and none is redundant with structured fields.

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 values need no explanation, and annotations cover the safety profile. The description fills the key gap (conditional mode parameters), though it leaves the distinct roles of highFuelEthanol versus pumpGasEthanol to be inferred.

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 78%, so baseline would be 3, but the description adds genuinely new meaning by specifying conditional per-mode requirements (e.g., fresh needs finalVolume; existing needs finalVolume/currentVolume/currentEthanol; correction needs tankCapacity/currentVolume/currentEthanol; ratio needs no volumes). The schema only marks five flat required params and does not encode these mode dependencies.

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 (Calculates) and resource (ethanol blend) and enumerates the four distinct modes (fresh, existing, correction, ratio), which differentiates it from sibling calculators like calculate_race_fuel_and_weight. An agent can identify exactly what the tool produces 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?

Provides clear mode-selection guidance by mapping each mode to its required inputs, and notes it runs without authentication or account data. It does not name sibling tools or state when a different calculator should be used instead, so it stops short of full alternative routing.

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 establish safety (readOnlyHint=true, destructiveHint=false, openWorldHint=false), so the bar is lower. The description still adds genuine context beyond them: no authentication required and no account data read or saved, plus a clear statement that the output is an estimate, not a directive.

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 the purpose and inputs before the disclaimers, with no filler. Slightly padded by restating inputs that the schema already enumerates.

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 an output schema present, return values need no explanation. The description covers purpose, inputs, safety posture, and a domain-appropriate caveat about validating with a tuner, leaving nothing an agent needs 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 the schema already documents all five parameters with units and constraints; baseline is 3. The description restates four of them but adds no syntax, unit, or range detail beyond the schema, and omits 'current' injector size entirely.

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+resource ('Estimate injector size') and enumerates the exact inputs it derives the estimate from (horsepower, fuel type, injector count, duty cycle). No sibling tool overlaps this domain, so an agent can identify it unambiguously.

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 implies the use case (sizing injectors from measured inputs) and adds a real caveat ('Confirm with your tuner and fuel pressure data'), but it never states when to prefer it over alternatives or what conditions disqualify it. There is no named sibling or exclusion criteria.

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 cover safety (readOnlyHint, destructiveHint=false, openWorldHint=false), so the bar is lower; the description adds real context the annotations do not — no authentication required, no account data read or saved, and a caveat that tire growth and converter/clutch slip affect real-world accuracy. That accuracy caveat is exactly the kind of behavioral note that earns credit.

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

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

Four sentences, front-loaded with the core computation before auth and caveats. Efficient and well ordered, with only mild overlap between the first and third sentences.

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 values need no explanation, and the description still covers purpose, key inputs, auth/data behavior, and accuracy limits. Complete enough to invoke correctly, short only of explicit sibling differentiation.

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 meaning beyond the schema: it ties the output to 'shift drop' (the nextGear parameter) and advises using a measured tire diameter rather than a nominal one. This nudges it above baseline without fully documenting the enum or unit parameters.

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

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

Specific verb and multiple concrete outputs ('Check speed, RPM, and shift drop') plus the required inputs (tire size, final drive, gear ratio). The resource is distinct from calculation siblings like calculate_brake_bias or calculate_corner_balance, though the description never names or contrasts a sibling explicitly, keeping it at a 4.

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?

'Use measured tire diameter when possible' gives a genuine input-selection hint, but there is no explicit when-to-use/when-not framing and no alternative tool named. Usage is implied by the purpose statement 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, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds genuine value beyond that: it discloses no authentication is required and that account data is neither read nor saved, which the annotations do not convey.

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

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

Purpose is front-loaded in the first sentence and the remaining sentences are short and purposeful, each adding a distinct piece of information. Slightly discursive with the closing 'before blaming setup' advice, but no real 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?

An output schema exists, so return values need no explanation, and the description covers purpose, input source, and read-only behavior. For a six-param pure calculation it is essentially complete, with only minor gaps around output interpretation.

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

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

Schema description coverage is 100%, so all six sector inputs and their units are already documented in the schema. The description adds no syntax, format, or constraint detail beyond 'sectors' already implied by the schema, 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 (compare) plus resources (two laps or sector sets) and the outcome (best theoretical lap), which is far more informative than a restatement of the name. It doesn't distinguish itself from any sibling by name, but the resource scope is distinctive enough that no confusion is likely.

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

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

Gives clear operating context ('Use sectors from timing, video, or data logs') and a domain caveat about comparing similar conditions. There are no explicit exclusions or named alternatives, but as a standalone calculation there is little to route against.

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 (readOnly, non-destructive, closed-world), the description discloses meaningful modeling assumptions: per-lap consumption applies to race, formation, and allowance laps, and finish weight retains only the selected reserve. These are non-obvious behavioral traits not derivable from the schema.

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

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

It is front-loaded with the outcome and then layered with assumptions and cautions; every sentence serves a purpose. The five-sentence block is dense but not padded.

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 an output schema present and full schema coverage, the description needn't explain return values, and it correctly focuses on assumptions and validation caveats for this 14-parameter calculator. Slightly more explicit guidance on raceMode/duration vs raceLaps usage would make it fully 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 coverage is already 100%, so the baseline is 3, but the description adds real semantics: how 'consumption' is propagated across lap types and what 'reserve' does to finish weight. That meaningfully supplements the parameter 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 opens with a specific verb ('Plan') and concrete resources: race fuel load, reserve, start weight, and minimum-weight margin. This clearly distinguishes it from siblings like calculate_ethanol_blend or calculate_fuel_injector_size, which compute different quantities.

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 implies the planning context and adds the caution to 'confirm your series weighing rules and validate consumption with real data,' which hints at when the result is trustworthy. However, it never states when to prefer this over the other fuel-related calculation siblings, leaving alternatives 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 cover the safety profile (readOnlyHint, destructiveHint=false, openWorldHint=false), so the bar is lower, and the description usefully adds that it needs no authentication and never reads or saves account data. It also discloses a real modeling limitation — no bars, bump stops, tires, or aero load — which is context the annotations cannot express.

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

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

Four short sentences, front-loaded with the core transformation before the behavioral and limitation notes. The middle sentence 'Wheel rate compares spring changes' is slightly redundant filler that could be folded into the opening 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?

With an output schema present, the description needn't explain return values, and annotations cover the read-only profile. It supplies auth context and modeling limits, which is nearly everything an agent needs for this stateless calculator; only unit-system handling is left 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%, so every parameter (including unitSystem and springAngle) is already documented with units and bounds. The description touches only springRate and motionRatio at a conceptual level and adds no syntax or unit nuance beyond the schema, 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?

States a specific transformation (spring rate + motion ratio → wheel rate) with the verb 'convert' and names the exact resource. An agent can distinguish it at a glance from neighbors like calculate_corner_balance or calculate_brake_bias, which compute different physical quantities.

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?

'for setup comparisons' and 'Wheel rate compares spring changes' give clear context for when this tool is appropriate, and the closing sentence rules out cases where the result would be misleading. It stops short of naming an alternative sibling or stating explicit prerequisites, so it stays at 4 rather than 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 cover the safety profile (readOnly, non-destructive, closed-world), and the description adds genuine context beyond them: no authentication required, no account data read or saved, and the important caveat that the result is a next-test pressure rather than a universal ideal.

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

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

Four front-loaded sentences that are mostly efficient: action first, then operational context, then an expectation-setting caveat, then a follow-up note. Little waste, though the caveat and the closing note touch on similar output-interpretation territory.

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 an output schema present, return values need not be explained, and the description supplies the remaining essentials: pure calculation, no auth, no account data, and interpretation guidance. An agent has enough to invoke it correctly, with only usage routing to siblings 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?

Schema coverage is 100%, so each parameter is already documented, including the unit-system enum and unit conventions. The description restates the three pressure inputs but adds no syntax or semantics beyond what the schema provides, so 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 clear transformation verb and names both the inputs (cold, hot, target hot pressures) and the output (the next cold pressure to try). It is specific about what the tool produces, though it does not explicitly distinguish itself from siblings like analyze_tire_temperatures.

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 input-to-output framing, and 'Recheck after the next run' hints at when the result applies. However, there is no explicit when-to-use or when-not-to-use guidance and no routing to an alternative tool for related tasks.

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

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

Adds context beyond annotations: no authentication required, does not read or save account data. Annotations already declare readOnlyHint/openWorldHint=false, so this reinforces rather than contradicts. Could disclose more about output interpretation, but the 'baseline not prescription' caveat is valuable behavioral guidance.

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

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

Four tight sentences: what it does, safety/auth context, scope limitation, and decision guidance. Front-loaded with purpose, zero 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?

Output schema exists so return values needn't be explained. Description covers purpose, safety, scope caveat, and usage context. Slightly richer guidance on interpreting results would complete it, but nothing essential is missing for correct invocation.

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

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

Schema coverage is 100% with units and field meanings fully documented. The description mentions camber and total toe conceptually but adds no unit or format detail beyond the schema. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

States a specific verb ('Check') and resource ('camber and total toe') and names the comparison targets ('autocross and track baseline ranges'). This distinguishes it from diagnostic siblings like diagnose_handling_issue and analyze_tire_temperatures.

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?

Clearly frames it as a baseline checker, not a vehicle-specific prescription, and notes that tire wear and driver feedback decide the next step. Implies when-not to over-rely on it, but doesn't explicitly name alternative tools to use for vehicle-specific recommendations.

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, destructiveHint=false, and openWorldHint=false. The description adds real value beyond that: it states no authentication is required, that no account data is read or saved, and that actual mounted diameter varies by tire model and pressure. These auth and accuracy caveats are exactly the behavioral context annotations cannot convey.

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

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

Four sentences, front-loaded with the computed outputs, then the auth/data-access note, then two accuracy caveats. Every sentence carries information and nothing is padded, though the auth clause is slightly tangential to the core comparison function.

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 values need no explanation, and annotations cover the safety profile. With all 7 parameters fully described in the schema and the description covering purpose, auth behavior, and accuracy limitations, an agent has what it needs, though no explicit sibling routing is provided.

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 every one of the 7 parameters documented including units, exclusiveMinimum/maximum bounds, and the unitSystem enum. The description adds no additional parameter meaning beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb (compare) and resource (tire sizes) and enumerates the exact outputs computed: diameter, circumference, ride height, and speedometer change. It clearly separates this from sibling calculate_* tools by naming the tire-size domain, though it does not explicitly name an alternative 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?

'Use manufacturer specs when available' implies this is an approximation tool to be preferred only when specs are unavailable, which is useful implied guidance. However, it never explicitly states when to choose this over siblings like calculate_tire_pressure_adjustment or analyze_tire_temperatures, so guidance remains implicit rather than explicit.

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=false, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description does add genuinely useful behavioral context beyond annotations: it records into vehicle history AND advances the tracker, a compound side effect not visible in the schema. However, it omits idempotency, what happens on a bad trackerId, or whether the tracker advance is reversible.

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 compound action (record + advance tracker) is delivered efficiently. It is arguably terse for an 8-parameter mutation but wastes no words.

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

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

An output schema exists, so return values need not be described, but with 8 undocumented parameters, no usage guidance, and a mutation with a non-obvious tracker side effect, the description is too thin. It should at least clarify the difference from update_maintenance and the meaning of the required fields.

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

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

Schema description coverage is 0% across 8 parameters, three of them required (vehicleId, trackerId, completedAt). The description names none of them and explains no formats, so the field-level burden falls entirely on parameter names. This leaves significant gaps for mileage, engineHours, logCount, and trackEvents.

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: 'Record completed maintenance in vehicle history.' The addition of 'advance its tracker' signals the special semantics of completing (versus creating or updating) maintenance. It is clear but does not explicitly distinguish itself from the sibling update_maintenance or create_maintenance.

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 guidance on when to use complete_maintenance versus create_maintenance, update_maintenance, or archive_maintenance. The word 'complete' implies finishing an existing maintenance item, but this is left entirely 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, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds useful context beyond that: no authentication required and no account data is read or saved, plus the caveat that tune targets depend on external factors. Return format is left to the 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?

Three short sentences, front-loaded with the conversion scope before caveats. Every sentence carries some weight, though the disclaimer about tune targets could be trimmed slightly without losing meaning.

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

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

For a simple, side-effect-free conversion utility with an output schema and full annotation coverage, the description supplies what an agent needs: scope, safety posture, and a usage caveat. Nothing critical is missing, though it could state the conversion direction or expected input scale.

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 afr, lambda, and the fuel enum are already documented in structured fields, establishing baseline 3. The description adds no format or constraint detail (e.g., scale ranges or units) beyond what the schema provides. It also does not clarify why both afr and lambda are simultaneously required.

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

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

Names a precise verb and resource ('Convert AFR and lambda') and enumerates the supported scales (gasoline, E85, methanol, race fuel), which cleanly separates it from nearby siblings like calculate_ethanol_blend or calculate_race_fuel_and_weight. An agent can identify the tool's job 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?

'Use this as a conversion reference' gives a clear context, and the final sentence implicitly warns that tune targets require additional engine/load/calibration context rather than this tool alone. It never names an explicit alternative tool or a hard when-not condition, so it stops short of a 5.

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

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

Annotations already declare non-destructive (destructiveHint=false), non-open-world mutation, and the description's 'additive' aligns with that, hinting the source session is left intact. However it does not disclose what is copied (laps, logs, setups), whether permissions beyond accessibility are needed, or any side effects.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though arguably under-specified rather than genuinely complete.

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

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

The output schema removes any need to describe return values and annotations cover the safety profile, so the remaining gap is the unexplained 'additive' behavior and what a copied session contains. Adequate but thin for a mutation 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?

Only one parameter exists and its name (sessionId) is largely self-documenting, but schema description coverage is 0% and the description never mentions the parameter or what 'accessible' means for it. It neither compensates for the coverage gap nor adds real meaning.

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 (create a copy of a driving session) and the word 'copy' distinguishes it from the create_session/update_session/archive_session siblings. The modifier 'additive' is unexplained, but the core action is unambiguous.

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

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

There is no when-to-use vs when-not-to-use guidance and no alternative named. The only usage signal is the embedded precondition that the session must be 'accessible', which is implied rather than stated as a rule.

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=false, destructiveHint=false, openWorldHint=false, covering the safety profile. The description adds genuine behavior beyond that: the copy is editable and item checks are reset. It still omits whether the source list is unmodified and whether copy requires an active connection.

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 action ('Create an editable copy') leads and the side effect ('checks reset') follows.

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 values need no explanation, and annotations cover safety. Still, the description leaves open how to obtain listId and whether the source list is affected, which matters for a mutating copy operation.

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

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

The single listId parameter has 0% schema description coverage, so the description carries the full burden, and it only implies the ID refers to an existing list. It gives no format, no source (list_shop_lists?), and no indication of what happens with an invalid ID.

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: 'Create an editable copy of a connected user shop list.' The word 'copy' and 'connected user shop list' implicitly distinguishes it from create_shop_list, but no sibling is named explicitly, so an agent must infer 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?

No when-to-use guidance: it never says to prefer this over create_shop_list, get_shop_list, or reset_shop_list_items, nor what preconditions ('connected user'?) must hold before copying. Usage must be inferred entirely 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that — it does not say whether saving is idempotent, whether an existing set with the same name is overwritten or rejected, or what the channels payload must contain.

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 short sentence with no filler, front-loaded with the action. It is efficient, though its brevity reflects under-specification rather than disciplined editing.

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 values need not be explained. However, for a two-parameter write tool with zero schema coverage and no annotation detail about overwrite/duplicate-name behavior, the description is too thin for an agent to invoke it confidently.

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

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

Schema description coverage is 0% and both parameters are required, so the description carries the full burden. It only loosely maps 'named' to the name param and 'chart channels' to the channels param, leaving the shape of each channel object completely undefined in both description and 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 gives a specific verb ('Save') and resource ('named set of chart channels'), which clearly distinguishes it from list_chart_channel_sets and delete_chart_channel_set. It does not explicitly name or contrast with those siblings, but the create semantics are unambiguous.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as list_chart_channel_sets or mark_chart_channel_set_used. The agent must infer context entirely from the tool 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the agent knows this is a non-destructive, local write. The description adds the ownership dimension (connected user vs an editable team), which is genuinely useful behavioral context, but says nothing about auth requirements, validation failures, or what constitutes an "editable" team.

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 create action front-loaded and no filler. It is efficient, though the brevity is partly under-specification rather than pure conciseness.

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

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

Six parameters with zero schema descriptions and only venue marked required, plus a personal-vs-team ownership switch, is a lot of unexplained surface for one sentence. An output schema exists so return values need no explanation, but field meaning and the teamId condition are absent, leaving the agent under-equipped 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?

Schema description coverage is 0% across 6 parameters, so the schema carries no meaning and the description must compensate — it does not. Nothing explains venue vs city vs region vs country/countryCode, nor whether teamId is required for the team case or what it accepts; the only weak hint is the incidental mention of "an editable team" alongside teamId.

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 ("Create a custom track") that is immediately distinguishable from the sibling update_, delete_, get_, and list_custom_tracks tools. It also adds scope ("for the connected user or an editable team"), which sharpens what the resource is. It stops short of naming which sibling to use instead for other operations.

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

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

The phrase "for the connected user or an editable team" implicitly tells the agent this is the creation path for a personal or team-owned track, contrasting with update/delete siblings. But there is no explicit when-to-use, no precondition (e.g. team must be editable by you), and no guidance on when to omit teamId.

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=false, openWorldHint=false and destructiveHint=false, so safety is covered and the description only adds that the vehicle must be 'accessible' (an implicit ownership/permission hint). It says nothing about what chartConfig must contain, whether duplicates are rejected, or how the saved chart is later retrieved.

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 padding, which is structurally fine, but the brevity comes from under-specification rather than discipline. It is short without being informative.

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 values need no explanation, but for a 7-parameter mutation with a nested chartConfig and an enum, the description leaves core calling information unstated. Only the safety profile from annotations fills part of the 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 0% across 7 parameters, so the description carries the burden of explaining them. It only alludes to vehicle and source log (2 of 7) and says nothing about title, the source enum ('analyzer' vs 'charts'), channelSetId, notes, or the nested chartConfig object.

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 ('Save') and resource ('favorite chart') plus the scoping entities (vehicle, source log), which distinguishes it from delete_favorite_chart and list_favorite_charts. It is clear but the phrase 'accessible vehicle' is vague and never explains how it relates to create_chart_channel_set, a nearby sibling.

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 indication of when to use this versus list_favorite_charts, create_chart_channel_set, or delete_favorite_chart, and no prerequisites such as needing an existing vehicle or session. The agent must infer usage entirely 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds one useful behavioral fact ('Deletes are not supported'), but says nothing about permissions, duplicate handling, or what happens to interval/reminder fields when omitted.

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 action, with no filler. It is efficient, though arguably too thin for a 9-parameter mutation 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?

An output schema exists so return values need not be described, but for a 9-param creation tool with 22% schema coverage and no documentation of the intervalType/intervalValue/reminderDaysBefore relationship, the definition leaves the agent guessing about required field semantics.

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 22%: just dueDate and doneDate are documented, while name, notes, category, vehicleId, intervalType, intervalValue, and reminderDaysBefore carry no description. The description text adds no parameter meaning at all, so 7 of 9 parameters are undocumented everywhere, a real gap for a creation tool with linked interval fields.

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 ('Creates a TuneWorks maintenance reminder or service item'), which is clear and distinguishable from generic siblings like create_vehicle. It does not, however, differentiate itself from update_maintenance, complete_maintenance, or archive_maintenance, which is the more pressing ambiguity for an agent.

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 only usage signal is the negative boundary 'Deletes are not supported.' There is no guidance on when to create vs. update_maintenance or complete_maintenance, nor any prerequisite (e.g., vehicle must exist, what happens if a similar reminder already exists).

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=false and destructiveHint=false, so the write/safe-mutation profile is covered. The description adds one genuine behavioral fact ('Deletes are not supported', i.e. no delete counterpart to this create), but says nothing about required-field handling, side effects on linked setups/logs, or auth needs for a 22-parameter mutation.

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, front-loaded sentences with no filler, so it is not bloated. However, this brevity is under-specification rather than disciplined concision given the tool's 22-parameter surface, so it lands at a minimum-viable 3.

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 values need not be explained. But with 22 parameters at 5% coverage, two enums, and no indication of how the many optional session attributes are used, the description is materially incomplete for a tool of this complexity.

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

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

Schema description coverage is only 5% (essentially just sessionDate), so the description carries the full burden for 22 parameters, including two enum fields and seventeen undocumented strings. It mentions no parameter at all, adding zero 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 ('Saves a new TuneWorks driving session'), which is enough to place it against update_session, copy_session, and archive_session. It is clear but does not explicitly name which sibling to prefer, so it stops short of a 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?

There is no when-to-use guidance, no preconditions, and no pointer to alternatives such as update_session or copy_session. The closing note about deletion is a scope remark, not usage direction, so the agent is left to infer everything.

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=false, destructiveHint=false, and openWorldHint=false, so the write-but-non-destructive safety profile is covered. The description adds only the 'deletes not supported' constraint; it says nothing about duplicate setup names, required vehicle existence, or side effects on related logs/sessions.

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 with zero padding and the primary action front-loaded. It is efficient but so terse that it omits information an agent needs, which limits the score.

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

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

For a 7-parameter mutation tool with nested setupData and only 43% schema coverage, this is thin. The output schema removes the need to describe return values, but missing parameter meaning, prerequisites, and sibling routing leave real gaps.

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

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

Schema coverage is only 43%, so the description carries the burden of clarifying parameters, yet it adds nothing. It does not explain setupName, vehicleId, dataLogIds, or influencedSessionId, leaving half the parameters 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?

States a specific verb+resource+scope: 'Saves a new TuneWorks setup for a vehicle.' The word 'new' cleanly separates it from update_setup, archive_setup, and list_setups in the sibling list, though those siblings are not 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 guidance on when to use this versus update_setup (for existing setups) or archive_setup (for lifecycle changes). 'Deletes are not supported' hints at a limitation but does not route the agent to any alternative, and no prerequisites are stated.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=false, so the write-but-not-destructive profile is covered. The description adds one genuinely useful behavioural detail — that categories and items can be created inline rather than in separate calls — but says nothing about permissions, side effects on related entities, or what happens on partial failure.

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 the verb first and no filler. Nothing in it is redundant with the title or annotations.

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 values need no explanation, and the annotation set covers safety. But for a 9-parameter creation tool with 11% schema coverage, the description leaves the agent guessing about required-field semantics ('purpose' values), the meaning of the optional scope IDs, and the relationship to add_shop_list_item/category.

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 11% (just the 'purpose' field), and 9 parameters exist, so the description is expected to carry meaning. It mentions only 'categories' and 'items' out of nine, leaving title, status, note, setupId, sessionId and vehicleId unexplained — notably the scoping IDs that determine which vehicle/session/setup the list attaches to.

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 ('Creates') and resource ('TuneWorks shop list, task list, or parts list'), which is clear enough to distinguish it from read siblings like get_shop_list or list_shop_lists. It does not, however, distinguish itself from near-neighbours such as copy_shop_list or update_shop_list, so an agent still has to infer that this is the from-scratch creation path.

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 mention of alternatives, even though obvious ones exist (add_shop_list_item and add_shop_list_category for extending an existing list, copy_shop_list for duplication). The phrase 'optionally including categories and items' hints at the trade-off but never states the rule.

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=false, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds the useful scope that the team is created 'for the connected user' (i.e., ownership is implied), but says nothing about creator role, duplicate-name behavior, or team 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?

A single front-loaded sentence with zero padding; nothing is wasted. Its brevity is a coverage problem (captured elsewhere), not a structural one.

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 values need not be explained, and annotations cover the safety profile. Still missing for a mutation tool are error/duplicate conditions, permission requirements, and any note on what happens to the creator's membership.

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

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

The schema has 0% description coverage for the sole `name` parameter, so the description carries the full burden — and it never mentions the parameter, its format, uniqueness, or length constraints. Only the tool name implies that `name` is the team name.

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 ('Create a new team') plus ownership scope ('for the connected user'), so the operation is unambiguous. It does not, however, distinguish itself from the other create_* siblings (create_vehicle, create_session, create_setup) beyond the resource noun.

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 guidance on when to create a team versus joining one, no prerequisites or permission requirements, and no mention of the surrounding team lifecycle tools (list_teams, send_team_invite, leave_team, delete_team). The agent must infer all routing decisions.

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=false, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds only the 'no deletes' scope note, which is marginally useful but largely redundant with destructiveHint=false. It says nothing about side effects on the garage, required permissions, or what a successful creation returns.

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 with the core action front-loaded and no filler. The second sentence is somewhat tangential for a create tool but is compact and not wasteful.

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?

Though an output schema exists (so return values need not be described), the definition is inadequate for a 19-parameter, 11-required creation tool with 5% parameter documentation. There is no enumeration of required inputs, no guidance on the enum-typed fields, and no usage context, leaving significant gaps.

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

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

Schema description coverage is 5% across 19 parameters (11 required), and the description contributes zero parameter information. For a tool requiring make, model, year, purpose, owner, displacement, engine type, aspiration, cylinders, fuel, and fuelRating, the definition leaves the agent entirely dependent on a nearly undocumented schema.

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

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

States a specific verb and resource: 'Adds a vehicle to the connected user's TuneWorks garage.' An agent knows this creates a vehicle. However, it does not distinguish itself from siblings like create_vehicle_make, create_vehicle_modification, or update_vehicle, which all operate on related garage entities.

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

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

No guidance on when to use this versus update_vehicle, archive_vehicle, or the other create_* siblings. The lone note 'Deletes are not supported' is a lifecycle caveat, not usage direction. An agent gets no signal about prerequisites or the appropriate context.

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

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

Annotations already declare this is a non-read-only, non-destructive, closed-world write. The description adds only the scoping detail 'connected user settings', which usefully signals the make is user-level data. It does not explain duplicate handling, permissions, or side effects, so it is adequate but thin given annotations carry the safety profile.

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

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

A single efficient sentence with the action front-loaded and nothing wasted. It is terse rather than padded, which is appropriate.

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 values need not be explained, but with 0% schema coverage across two parameters and no usage or behavioral detail, the definition is too thin for a write tool that stores user settings.

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

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

Schema description coverage is 0%, so the description must compensate, but it names neither parameter. The optional teamId in particular is undocumented anywhere, and 'make' format/constraints are never described, leaving real ambiguity.

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?

'Add a custom vehicle make' states a specific verb and resource, and 'vehicle make' distinguishes it from the sibling create_vehicle (which creates the vehicle, not the make lookup). It does not explicitly call out its relationship to create_vehicle or update_vehicle_make, so it stops short of a 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?

There is no guidance on when to create a custom make versus using an existing one, nor any mention of related siblings like update_vehicle_make or delete_vehicle_make. The agent is left to infer all usage context.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so safety profile is covered and the description's 'Create' verb is consistent with it (no contradiction). The description adds only the 'editable vehicle' precondition, and says nothing about required permissions, how required vs optional fields behave, or what happens on a non-editable vehicle.

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

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

A single front-loaded sentence with no filler. It is efficient, though it is arguably under-specified rather than truly concise given the tool's complexity, which keeps it just short of a 5.

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 mutation with 20 mostly undocumented parameters and 0% schema coverage, the description is far too thin. An output schema exists, so return values need not be explained, but the complete absence of parameter semantics and write-behavior context leaves the definition inadequate for correct invocation.

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

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

There are 20 parameters (6 required) with 0% schema description coverage, and the description supplies no parameter meaning whatsoever. Fields like category, system, status, brand, partName, replacedModId, and installMileage are entirely undocumented in both the schema and the description, so an agent cannot infer their formats or intent.

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

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

The description uses a specific verb+resource ('Create a structured modification') scoped to a TuneWorks vehicle, which clearly separates it from create_vehicle, create_vehicle_make, and update_vehicle_modification by object. It does not, however, explicitly name any sibling or clarify how it differs from update_vehicle_modification beyond the create/update verb.

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 'editable TuneWorks vehicle' hints at a precondition (the vehicle must be editable), but there is no explicit when-to-use, when-not-to-use, or routing to alternatives such as update_vehicle_modification. An agent gets only a faint contextual cue, not real 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 destructiveHint=true, but the description adds meaningful context beyond them: 'Permanently' communicates irreversibility, and 'after explicit confirmation' discloses the confirmation gate that maps to the required `confirmed` flag. It still omits permission/auth requirements and side effects on dependent 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?

A single front-loaded sentence with no filler; the destructive action and its prerequisite are both conveyed economically.

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 values need not be explained, and the annotations supply the safety profile. The description is nearly complete for this mutation, though it could note behavior when `confirmed` is false or 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 0% for two parameters, so the description must carry the burden. It only loosely gestures at `confirmed` via 'explicit confirmation' and says nothing about the `trackId` format or what value of `confirmed` is expected.

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 ('delete') and resource ('custom track'), making it readily distinguishable from update_custom_track, get_custom_track, and list_custom_tracks by name and action. It does not, however, explicitly contrast itself with those siblings in the description text.

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?

'after explicit confirmation' implies a precondition, but the description gives no guidance on when to delete versus update/archive instead, nor any exclusion or warning beyond the confirmation gate. Usage is 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 destructiveHint=true and readOnlyHint=false, but the description adds that deletion is permanent and requires explicit confirmation. This goes beyond the annotation by emphasizing irreversibility and the confirmation gate. Authorization is only hinted at via 'authorized ECU file'.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to stating the action, permanence, and confirmation requirement.

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

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

For a destructive delete with an output schema and destructive annotations, the description covers the core safety message of permanence and confirmation. It remains thin on authorization requirements and does not explain the 'id' parameter, leaving gaps for a destructive operation with no schema parameter descriptions.

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 0% schema description coverage across two required parameters, the description must carry the full burden of explaining parameters. It partially clarifies the 'confirmed' parameter through 'explicit confirmation' but says nothing about what 'id' identifies or its expected format.

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 ('delete'), resource ('ECU file'), and permanence ('Permanently'), making the operation clear. It does not explicitly differentiate from sibling ECU file tools or name alternatives, but the verb distinguishes it from inspect/list/process/retry sufficiently.

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 'after explicit confirmation' implies a required precondition, which aligns with the required 'confirmed' parameter. However, it gives no guidance on when deletion is appropriate versus alternatives, nor what to do if confirmation has not been obtained.

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