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

The closing "Read-only" merely restates readOnlyHint=true, so no credit there. Useful added context is the conditional coverage of connected-vehicle support and the disclosure that cancellation behavior is covered, but nothing is said about response shape, length, or cost that goes beyond the existing annotations and 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?

The purpose statement is front-loaded and the enumerated content list is dense with information rather than filler. It runs slightly long for a no-argument informational tool, but each listed item corresponds to real returned content.

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

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

For a zero-parameter, read-only informational tool with an output schema and full annotation coverage, the description says enough to call it correctly: what is covered, that it is read-only, and that it adapts to a configured vehicle. Only the relationship to sibling tools 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?

The tool takes zero parameters and the schema is empty, so the baseline of 4 applies; there is no parameter semantics for the description to add or omit.

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?

"Explain every calibration MAVForge supports" is a specific verb+resource, and the enumeration (preconditions, physical steps, parameters changed, verification, cancellation) tells the agent exactly what the answer covers. It never names or contrasts with a sibling like mavforge_capabilities or diagnose, so differentiation is left implicit.

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

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

Usage is only implied: an agent can infer it should call this when asked how to perform a calibration, and "includes support for the connected vehicle when one is configured" hints at a conditional context. There is no explicit when-to-use, when-not, or pointer to an alternative for general capability or fault questions.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description corroborates rather than repeats: it specifies that firmware checks are run 'not change' and that parameters are downloaded, plus a concrete latency expectation ('several seconds'). It also flags that `vehicle_text` is untrusted and issues an explicit safety constraint against declaring the vehicle airworthy — behavioral context the annotations cannot carry.

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

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

Front-loaded with the core purpose, then layered with behavior, output semantics, and safety constraints — each sentence carries information. Slightly dense, with the finding-kind enumeration and the safety admonition competing for space, but nothing is wasted.

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

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

For a parameterless read-only diagnostic whose output schema exists, the description supplies everything the agent still needs: what is collected, the severity vocabulary for findings, the latency expectation, and the handling of untrusted vehicle text. No meaningful gap remains.

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

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

Zero parameters, so there is no schema semantics to supplement and the baseline applies. The description instead documents the finding taxonomy (`fault`, `warning`, `suspected`, `not_checked`, `passed`), which meaningfully improves interpretation even though a full output schema exists.

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 first sentence names a specific verb and scope ('Diagnose configuration and readiness problems'), and the follow-up enumerates exactly what the tool touches: sensor health, firmware pre-arm checks (run, not change), parameters, platform rules. That enumeration implicitly distinguishes it from the parameter-centric siblings like params_list and params_diff.

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 scope phrase 'configuration and readiness problems' gives an implied usage context, and the latency note hints at a cost trade-off. However, no sibling tool is named as an alternative and there is no explicit when-not-to-use guidance versus params_diff or vehicle_status.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false. The description adds meaningful context beyond those: it explicitly states no vehicle contact and previews the per-operation metadata returned (permission, modification status, availability vs. planned), which helps an agent interpret results.

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: the primary purpose and returned attributes come first, followed by the important safety/scoping caveat. 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, the description need not enumerate return values, and it appropriately focuses on what the list contains and that no vehicle is contacted. It could be slightly stronger by stating how this discovery tool relates to the executable operation tools, but it is sufficient for a zero-parameter call.

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 zero parameters, so the schema needs no further semantic explanation. The description correctly adds nothing about inputs, which is appropriate for a parameterless discovery call.

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

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

States a specific verb (List) and resource (MAVForge operations), and names the three attributes returned (required permission, vehicle modification, availability). It does not explicitly distinguish itself from siblings like params_list or diagnose, so an agent must infer that this is the capability-discovery 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?

Usage is only implied: the tool is for learning what operations exist and their constraints. 'Does not contact the vehicle' hints at when it is appropriate, but there is no explicit when-to-use rule or named alternative for querying live vehicle/parameter state.

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

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

The annotations establish non-read-only, non-destructive, non-idempotent, and closed-world behavior. The description adds materially useful context: it writes a new host-side backup file, does not modify the vehicle, never overwrites an existing file, and can return partial status if some parameters are missing.

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

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

The description is front-loaded with the core action and side effect, then adds only decision-relevant details such as no overwrite, backup_id, and partial status. It is appropriately sized with no filler.

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

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

With no inputs, an output schema, and annotations covering safety hints, the description fills the remaining gaps: host-side file creation, overwrite behavior, return identifier, and partial-success condition. Nothing essential for correct invocation 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?

There are zero input parameters, and schema coverage is 100%, so no input parameter semantics are needed. The mention of backup_id is return-value context rather than input-parameter explanation, making the 0-parameter baseline of 4 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 gives a specific verb and resource: download every parameter and save it as a new backup file, including vehicle identity and firmware version. The word 'backup' and the link to params_diff distinguish it from the list/get/diff siblings, so an agent can select it without opening the schema.

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

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

It gives a clear usage context ('Recommended before any configuration work') and links the output to params_diff. It does not explicitly state when not to use it or point to params_backups as the alternative for listing existing backups, so it stops short of full when/when-not guidance.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely new behavioral context by clarifying that no vehicle connection is opened, which is the key operational fact an agent needs to avoid assuming a live session.

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 clipped sentences, the enumeration first and the operational caveat second. No filler, and the most decision-relevant fact is front-loaded.

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

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

With no parameters and an output schema present, the definition covers what an agent needs to invoke it safely. It stops short of the one remaining useful detail: how it differs from the singular params_backup and whether results are ordered or paginated.

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

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

The tool takes zero parameters, so there is nothing to disambiguate; baseline 4 applies. The parenthetical field list adds orientation about the response shape but is partly redundant with the existing output schema.

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

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

States a specific verb and resource ('List saved parameter backups') and even previews the record fields returned (id, time, vehicle, firmware, completeness). It implicitly separates itself from the singular params_backup by describing an enumeration of already-saved records, though it never names that sibling 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?

The 'Does not contact the vehicle' clause implies this is the offline/snapshot path rather than a live-fetch tool like params_diff, but the description never says when to choose this over params_backup or params_diff. 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?

With readOnlyHint/idempotentHint already declared, the description still adds real behavioral context: the backup-vs-backup path never contacts the vehicle, and mismatched firmware/board/vehicle type or incomplete data is surfaced via 'warnings' that limit what the diff means. It also warns that 'volatile' entries (boot counters, boot-time calibration) are normally not configuration differences — interpretive guidance found nowhere in the annotations. Minor redundancy in restating 'Read-only'.

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

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

The core mode split is front-loaded in the first two sentences and the caveats follow in a logical order (warnings, then volatile entries). Every sentence earns its place except the bare 'Read-only', which repeats the 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 description correctly spends its budget on the interpretive traps an agent would otherwise get wrong (mismatch warnings, volatile fields). What's missing is any note on diff granularity or how large result sets are handled, which is modest but real for a comparison tool.

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

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

Schema description coverage is 0%, so the description must carry the load, and it does: it identifies backup_id's provenance (from params_backups) and explains the semantic effect of against_backup_id (switch from live comparison to backend-only comparison). It could be sharper on what happens if both IDs are absent or on ID format, but both parameters gain meaning beyond the bare 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 ('Compare parameters with a saved backup'), and names the sibling that supplies the backup_id ('from params_backups'). It also distinguishes its two modes (live comparison vs. backup-vs-backup), so an agent can place it against params_get, params_list and params_backups without opening a schema.

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

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

Explicitly states the default behavior (compares the live vehicle) and the alternative mode ('with against_backup_id, compares two backups without contacting the vehicle'), which is a clear when-to-use split. It does not explicitly say when not to use it, e.g. when only looking up a single parameter's value via params_get, so it falls short of the 5 bar.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds value beyond that: the name syntax constraint (1-16 letters, digits, underscores) and the specific `param_not_found` error case, which tells the agent how to interpret a miss.

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 core action and followed immediately by the safety note and the failure behavior. No filler.

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

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

With an output schema present and annotations covering the safety profile, the description only needs to handle input semantics and error behavior, which it does. The one gap is that it never names params_list as the fallback for discovery, leaving that inference to the agent.

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

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

Schema description coverage is 0%, so the description must carry the parameter meaning, and it does — it specifies the accepted character set, length bound, and that the match is exact. It is not exhaustive (case sensitivity is only hinted at by 'exact name'), so a 4 rather than a 5.

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 ('Read one parameter') plus an exact lookup mode ('by exact name'), which implicitly separates it from params_list. It does not name the alternative sibling explicitly, keeping it shy 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?

Usage is implied: a single-parameter lookup by exact name is the natural alternative to params_list, and the failure mode tells the agent what happens on a bad name. However, it never says 'use this when you know the exact name, otherwise use params_list' or states prerequisites.

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

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

The annotations already declare read-only, idempotent, non-destructive, and closed-world behavior, so the description is not burdened with safety details. It adds useful operational context beyond annotations: it may take a few seconds on slow links, can return partial results, exposes missing indices, and warns about float precision 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?

The description is front-loaded with what the tool does, followed by operational details. Every sentence adds useful information without wasteful repetition.

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

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

An output schema exists, so the description need not fully define return values, but it still helpfully documents partial status, missing_indices, and precision_limited. It is complete for calling the tool, though it lacks explicit sibling-routing guidance.

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 carry the meaning of the single parameter. It does so well by explaining that the pattern is optional, case-insensitive, and glob-like, with a concrete example such as 'COMPASS_*'.

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: download all parameters and return those matching an optional glob. It is clear what the tool does, but it does not explicitly distinguish itself from siblings like params_get or params_backup.

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 optional glob filter and read-only nature imply when the tool is useful, but there is no explicit guidance on when to use it instead of params_get, params_backup, or params_diff. The performance note about slow links helps set expectations but does not route between 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 readOnly, idempotent, closed-world and non-destructive, so the trailing 'Read-only' adds nothing. The one piece of genuine behavioral context beyond the annotations is that the tool reports 'any other vehicles heard on the link', revealing a broader scan scope than the name suggests; otherwise the field enumeration likely duplicates 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?

It is one compact sentence with the identity verb front-loaded and the returned facets following. The closing 'Read-only' is filler given the annotations, a small waste in an otherwise tight definition.

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

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

With no parameters, a present output schema, and full annotation coverage, the description only needs to orient the agent, which it does by enumerating the identity facets. The missing piece is a one-clause contrast with vehicle_status so the agent knows which sibling answers 'what is this vehicle' vs 'what is it doing now'.

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

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

The tool takes zero parameters, so there is no parameter semantics to explain and the baseline of 4 applies. Nothing in the description misrepresents the no-argument invocation.

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 ('Identify the connected vehicle') and enumerates the identity facets returned: autopilot, vehicle type, firmware/hash, board IDs, MAVLink capabilities, SITL status. It does not explicitly distinguish itself from the closest sibling, vehicle_status, leaving the agent to infer that this is static identification vs. live state.

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

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

Usage is only implied by 'Identify the connected vehicle' and the presence of 'simulator (SITL)' in the content list. No sentence says when to prefer this over vehicle_status or diagnose, and no exclusions or prerequisites are given.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds genuinely non-redundant behavior: it requests single messages without altering stream rates, it reports `unavailable` for anything not received, and it flags STATUSTEXT as untrusted vehicle data. The trust warning in particular is safety-relevant context the structured fields 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?

The long field enumeration leads, followed by the read-only/non-disruptive guarantee and the `unavailable` and trust caveats, so no sentence is buried. The list is dense but every item corresponds to real returned data; a slightly tighter grouping would make it easier to scan.

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

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

With an output schema present, the description need not restate return structure, and it still explains the one ambiguous output field (`unavailable`) plus the semantics of the pre-arm check boolean. For a zero-parameter read tool, an agent has everything needed to call it and interpret the result correctly.

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

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

The tool takes zero parameters, so the baseline is 4 and there is nothing for the description to disambiguate. The only input-adjacent note, that nothing is configurable and single messages are requested, is consistent with an empty schema.

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

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

The description names a specific resource (a status snapshot of a vehicle) and enumerates the exact fields captured: arming state, flight mode, sensor health, pre-arm check enabled/passing, battery, GPS fix, and STATUSTEXT. This is far more specific than the bare name, and the pre-arm 'false = switched off on the vehicle' clarification prevents a serious misreading.

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 tells the agent this is a read-only, non-rate-changing single-message fetch, which implies a diagnostic/checking use, but it never says when to choose it over siblings like vehicle_info or diagnose. No exclusions or alternatives are named, so the agent must infer the boundary from sibling names alone.

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