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

Annotations already declare this as a safe, read-only, idempotent operation, so the bar is lower. The description adds meaningful interpretive boundaries by saying it analyzes Header periodicity and callback intervals 'separately' and explicitly does not infer DDS latency or physical sample jitter, which helps an agent avoid misusing the 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 short sentences with no filler, and the main purpose is front-loaded before the negative scoping caveat. Every sentence adds distinct 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 do not need description coverage, and the annotations carry the safety profile. However, for a three-parameter analysis tool with 0% schema description coverage, the description is too thin: it never explains duration or expected_rate_hz, which are central to a periodicity analysis.

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 all three parameters, and the description does not explain what topic, duration_s, or expected_rate_hz mean or how they affect the analysis. With three undocumented parameters, the description fails to compensate for the schema 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?

The description uses a specific verb (Analyze) with a specific resource (ROS Header periodicity and callback arrival intervals), so the tool's purpose is identifiable. It does not explicitly differentiate itself from the similar sibling analyze_timestamp_series or from inspect_ros_topic/inspect_ros_clock, which keeps it from 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 gives a negative boundary ('Does not infer DDS latency or physical sample jitter') but does not say when an agent should choose this tool over analyze_timestamp_series, inspect_ros_topic, or other ROS/time siblings. There is no positive when-to-use guidance or 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 cover safety (readOnly, idempotent, non-destructive), so the description's job is to add trust semantics — and it does: user-supplied evidence is explicitly called an assertion rather than independent verification, which tells the agent how to interpret results from the paired-events path. Return format is left to the output schema, which is acceptable.

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 with no filler, and the core capability is front-loaded. The telegraphic phrasing ('repeats/backwards/jumps') is dense but still decodeable.

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 safety. What remains missing is parameter-level detail for synthetic/rate and any sibling differentiation, making the definition merely adequate for a 6-parameter analysis 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 carries the full burden, yet it never mentions 'synthetic' or 'expected_rate_hz' by name and does not explain the correspondence_method enum choices. It adds real meaning for timestamps_ns units, paired events, and evidence trust, but at 6 parameters it leaves substantial gaps.

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 ('Analyze int64 ns intervals') and enumerates the anomalies it detects (repeats/backwards/jumps). It does not distinguish itself from the sibling analyze_ros_timestamps, so an agent must infer which analyzer to pick.

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 the detection list, and the one explicit condition — paired fit allowed 'only with explicit trusted correspondence evidence' — is a constraint, not a routing rule. No when-to-use/when-not-to-use guidance versus analyze_ros_timestamps or compare_ros_topics is 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, closed-world behavior, so safety is covered. The description adds a genuinely useful caveat that the sampling phase is not a physical clock offset, plus the clock-domain compatibility requirement, but it never says what happens when domains are incompatible or that the call is time-bounded.

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 dense sentences with no filler, and the action is front-loaded before the caveat. The final sentence is terse to the point of being cryptic, but it is information-bearing rather than padding.

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

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

An output schema exists, so return values need not be explained. However, for a sampling-and-matching tool with a duration budget and a tolerance parameter, the description omits how long it blocks and how tolerance interacts with the strategy, leaving 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 description coverage is 0% across 5 parameters, so the description must carry the load. It names the two topic inputs and both strategy enum values, but says nothing about duration_s (a bounded sampling window, max 30s) or tolerance_ns (nanosecond tolerance used with the tolerance strategy), leaving the two numeric knobs entirely 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 action and resource: sample two ROS topics simultaneously and perform a one-to-one exact/tolerance match. It is clearly distinct from siblings like analyze_ros_timestamps or list_ros_topics, though it does not name those alternatives 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 phrase 'require explicit compatible clock domains' functions as an implied precondition for use, but there is no explicit when-to-use/when-not guidance and no routing to a sibling such as analyze_ros_timestamps for non-paired analysis.

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; the description reinforces this with 'No files or system settings are changed,' which adds modest scope context. It omits that live collection with duration_s (up to 30s) actually takes time and samples data, which is behaviorally relevant.

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 clauses with the key safety guarantee front-loaded and no filler. 'Return or Markdown with JSON evidence' is slightly redundant but the 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?

An output schema exists so return values needn't be explained, and annotations cover safety. However, for a 5-parameter tool at 0% schema documentation, leaving domain, topics, interface, and duration_s unexplained (and referencing nonexistent 'thresholds') makes the definition incomplete 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 description coverage is 0%, so the description must carry parameter meaning, and it does not. It mentions 'configurable thresholds,' yet no threshold parameter exists in the schema, and domain, interface, topics, and duration_s are never explained — domain/topics especially need semantics an agent can't infer.

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 (collect/generate report) and resource (Linux time-sync evidence + deterministic findings), with output format noted. It does not distinguish itself from siblings like get_time_sync_logs or inspect_time_services, so an agent cannot tell when this 'report' differs from those.

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?

'Collect live Linux evidence and deterministic findings' implies this is the aggregate/analysis tool versus raw getters, so usage is inferable. But there is no explicit when-to-use, when-not, or named alternative among the many time-sync siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so safety is covered. The description adds content-level detail beyond the annotations — which chronyc subcommands are read (tracking, sources, sourcestats) and the units of the reported values (ns offsets, ppm frequency) — but says nothing about failure modes such as chronyd not running.

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

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

One sentence with no filler, front-loaded on the verb, and it packs the data sources and units efficiently. It is not so short as to be cryptic, though the unit details could arguably be left to the output 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?

With zero parameters, full annotation coverage, and an output schema handling return values, the description only needs to say what is read — which it does. The remaining gap is not naming the chrony-vs-PTP alternative, which is a usage-guidance issue more than a completeness one.

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, which is the baseline-4 case; there is nothing to document. The description correctly conveys the tool is parameter-free by describing a fixed read of three chronyc outputs.

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 ('Read') and resource ('chronyc CSV tracking, sources and sourcestats'), so an agent knows it retrieves chrony daemon state. It does not explicitly differentiate from siblings like get_ptp_status or inspect_time_services, leaving the agent to infer chrony vs other time sources.

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 the word 'chronyc' — an agent can infer this applies to chrony-synced hosts, but the description never says when to prefer it over get_ptp_status or inspect_time_services. No exclusions or preconditions 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 readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds one genuinely useful trait — that values reflect *actual runtime* state rather than declared configuration, and that unsupported adapters are surfaced — but says nothing about output shape or how missing commands are signalled.

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

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

One sentence, front-loaded, with no filler or restated title. It is a dense comma-separated list rather than a well-structured statement, which costs minor readability but not length.

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 a full output schema and rich annotation coverage, the description only needs to convey purpose and scope, and it mostly does. It still leaves the agent unsure what "diagnostic capabilities" scope contains relative to the timestamp/ROS siblings, which matters in a crowded tool family.

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 with 100% schema coverage, so there is nothing to disambiguate; baseline 4 applies. The description introduces no misleading parameter-like concepts.

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 sentence names a verb ("Report") and lists content categories (runtime dependencies, command availability, ROS Bridge, unsupported adapters), so the general intent is inferable. However, it never states what resource is being described at a level an agent can act on without seeing the tool name, and the phrasing reads like an internal changelog rather than a capability statement.

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

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

No when-to-use guidance, no prerequisites, and no routing against siblings such as get_timestamp_capabilities or inspect_time_services, even though the naming collision makes differentiation the key selection problem. The agent must guess based on the name 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 already declare read-only, idempotent, non-destructive, local behavior. The description adds useful context beyond those annotations: it communicates that communication happens over a configured UDS, that domain values are constrained, and explicitly that ptp4l is never started. This is meaningful behavioral disclosure for a status tool.

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

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

The description is compact and front-loaded, with no wasted sentences. It could be slightly clearer by expanding or removing ambiguous terms like 'five datasets' and 'configured UDS,' but it remains efficient.

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

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

An output schema exists and annotations fully cover safety/read-only semantics, so the description does not need to explain return values. It adds enough invocation context for a read-only PTP status query, though the nature of the five datasets remains somewhat opaque.

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 full burden for explaining the two parameters. It only restates the domain range (0..127) already encoded in the schema and vaguely mentions 'interface/port association,' without explaining interface naming, what a domain represents, or how the UDS is selected/configured.

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 clear verb ('Query') and resource ('PTP status' via LinuxPTP GET datasets), so an agent can identify the operation. However, jargon like 'five LinuxPTP GET datasets' and 'configured UDS' slightly obscures what exactly is returned, and it does not explicitly distinguish itself from sibling status tools such as get_chrony_status.

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 'verify interface/port association' implies a usage context, and 'Never starts ptp4l' clarifies an important constraint. But there is no explicit guidance on when to choose this tool over alternatives like get_chrony_status or inspect_time_services.

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 one genuinely useful piece of context — that results are capability-only and not proof of synchronization — but says nothing about privileges ethtool may require or how to interpret an empty/unsupported result.

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 action stated first and the interpretive caveat second. 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?

The tool is simple: one required parameter, an output schema present so return values need not be described, and annotations covering the safety profile. The description covers what it reads and warns about misinterpreting the output; only privilege requirements for ethtool are unaddressed.

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

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

Schema coverage is 0%, so the description is the only prose source, and it says only 'for one interface'. The single `interface` parameter has a visible regex pattern in the schema that constrains the name format, so the schema carries most of the meaning; the description adds scope (one interface at a time) but no naming or format guidance.

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: read `ethtool -T` for a single interface. That is distinguishable from siblings like get_ptp_status or get_chrony_status, which report current state rather than hardware capability. It does not explicitly name which sibling to use instead, but the resource is precise.

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 caveat 'Capabilities do not prove current PTP synchronization' implies that this tool answers a hardware-support question and that get_ptp_status is the tool for live sync state, but that routing is left to inference rather than stated. No prerequisites or exclusions are spelled out.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the description wisely spends its words elsewhere: it discloses that output is redacted and bounded, and that journal permissions may restrict the evidence returned. That permission caveat is a real behavioral trait an agent could not infer from annotations.

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; the core operation comes first and the temporal constraints follow. Every clause carries information an agent needs.

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 need no explanation, and annotations cover safety. Bounds, time format, defaults, and a permission caveat are all present; only the limit parameter and what 'redacted' concretely strips are left unstated.

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

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

Schema coverage is 0%, so the description must compensate, and it does so well for since/until: timezone-aware ISO8601, max 7-day window, one-hour default. It says nothing about limit (default 100, max 500) or the service enum, but the enum values are self-descriptive, leaving only a minor 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 ('Read ... journald entries') and qualifies it as 'bounded, redacted', which separates it from status-oriented siblings like get_chrony_status or get_ptp_status. It does not explicitly name a sibling, but the log-retrieval scope is unmistakable.

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 concrete defaults ('default last hour') and a hard bound ('at most 7 days') that imply when the tool is appropriate, but never says when to prefer this over inspect_time_services or a status tool. Usage is implied rather than prescribed.

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 closed-world, so the safety profile is covered. The description adds genuinely non-structured information: only explicitly configured relationships are reported and none are inferred from co-location, which tells the agent how to interpret missing edges in the result.

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

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

Two sentences with no filler: the first declares the return content, the second declares the key limitation. Both earn their place and the payload description 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 an output schema present, return shape needn't be described, and zero parameters remove input ambiguity; annotations cover safety. The only residual gap is guidance on when to choose this against the many time/clock siblings.

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 for the description to disambiguate; baseline 4 applies. The schema itself confirms an empty argument 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?

States a specific verb+resource: returns the explicitly configured clock graph, directed mappings, and validity/uncertainty data. That is clearly distinct from live-status siblings like get_ptp_status or get_chrony_status, though no sibling is named explicitly to make the routing 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?

The note 'No relationship is inferred from sharing a host' scopes what the tool will and won't report, which implies its usage (static configuration view rather than discovered topology). However, it never says when to prefer this over inspect_time_services, get_ptp_status, or inspect_ros_clock, so selection is left to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so restating 'read-only' adds little. The genuinely additive content is the scope disclosure that sim time is not compared to UTC, which tells the agent what this tool will not report; however, nothing is said about how observation is performed or what the observation window affects.

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

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

Two compact sentences with the core observation capability front-loaded and the scope caveat last. Minor waste in 'read-only' duplicating the readOnlyHint annotation, but nothing else is padding.

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

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

An output schema exists, so return values need not be explained, and the safety profile is covered by annotations. The remaining gap is the sole parameter, which is left undefined for a tool whose whole usefulness depends on watching the clock over an interval.

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 there is one parameter, duration_s (default 2, range 0.1-30), whose meaning is entirely undocumented in both schema and description. The most plausible reading is an observation window, but the agent must guess that, and guessing wrong changes whether a pause or backwards jump is even detected.

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 (/clock) and specific operations (observe progression/pause/backwards, query per-node use_sim_time), which is far more than the tool name alone conveys. It is reasonably distinguishable from siblings like analyze_ros_timestamps or compare_ros_topics, though it never explicitly contrasts itself with them.

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

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

Usage is implied rather than stated: an agent can infer this is the ROS simulation-clock diagnostic tool, and the closing scope note ('simulation time is never compared to UTC') hints at an exclusion. But no sibling is named and no condition is given for choosing this over analyze_ros_timestamps or get_timestamp_capabilities.

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 safety is covered. The description adds genuine behavioral context the annotations don't: sampling is time-bounded (0.1–30 s), capped by a configured sample limit, and reports Header timing separately from callback-arrival timing.

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 dense sentence that front-loads the verb, the scope and the two timing dimensions; nothing is redundant or 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?

An output schema exists, so return values need not be explained, and annotations cover safety. What remains thin is routing guidance against the many sibling ROS/time tools, which the description does not address.

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%, but with only two parameters and all constraints (min 0.1, max 30, default 5, topic regex) encoded in the schema, the burden is light. The description only restates the duration range and says nothing about the topic string beyond what the pattern shows, so it adds marginal value.

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

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

The description gives a specific verb and resource: sample one topic and split inspection into Header vs callback-arrival intervals, which tells the agent exactly what analysis is performed. 'One topic' implicitly separates it from compare_ros_topics and list_ros_topics, but no sibling is named explicitly.

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

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

There is no when-to-use or when-not-to-use guidance and no named alternative. The agent must infer from the name and from the sibling list whether this or analyze_ros_timestamps / compare_ros_topics is the right entry point.

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 the read-only, idempotent, non-destructive, closed-world nature of the tool. The description adds useful domain context by noting the scope is allowlisted time services and that coexistence alone is not an adjustment conflict, which helps the 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?

The description is two short sentences with no wasted text, and the main purpose is front-loaded before the interpretive caveat.

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

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

Given the rich annotations, zero-parameter schema, and existing output schema, the description is nearly complete. It explains the inspected data and a key interpretation caveat, though it could better route the agent among sibling diagnostic tools.

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

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

The tool has zero parameters, so the baseline is 4. The description appropriately does not discuss parameters because none exist.

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

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

The description states a specific verb and resource: reading systemd states and ExecStart values for allowlisted time services. It is clear what the tool does, though it does not explicitly distinguish itself from siblings such as get_chrony_status or get_ptp_status.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. The second sentence hints at interpreting coexistence versus adjustment conflict, but it does not provide usage conditions or exclusions.

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

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

Annotations already cover read-only, idempotent, closed-world and non-destructive, so the bar is lower; the description still adds two non-obvious traits: no root privileges are required, and incomplete results are kept rather than erroring out. That partial-evidence behavior is exactly the kind of context an agent needs to interpret a short list. It does not discuss ordering or how missing link/speed data is presented.

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 capability scope is front-loaded in the main clause and the two trailing facts are compressed into a short fragment with no filler. The fragment style is terse to the point of being cryptic, which slightly undercuts readability.

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 safety is fully covered by annotations, so the remaining burden is small. The description adequately conveys scope, privilege level and partial-result behavior; minor gaps are ordering and whether down interfaces are included.

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 is 4. The description's enumeration of returned fields is a useful proxy for what the call surfaces, though it is not strictly parameter information.

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 local Linux interfaces') and enumerates the returned attributes (sysfs state, link speed, driver, timestamp/PHC capabilities), which clearly separates it from the time-sync and ROS siblings. It stops short of explicitly naming those siblings or saying it is the inventory step preceding them.

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?

'Ordinary user' implies this is a non-privileged discovery call, and 'partial evidence retained' hints at tolerant failure, but there is no explicit when-to-use or when-to-prefer-an-alternative guidance relative to siblings like get_timestamp_capabilities or get_ptp_status. Usage is implied rather than directed.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful context about the "optional distribution-matched Bridge," but does not explain fallback behavior or what happens if the bridge is unavailable.

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

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

A single front-loaded sentence covers the main discovery targets with little waste. The phrase "optional distribution-matched Bridge" is slightly jargon-heavy and could be clearer, but the description remains appropriately concise.

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 zero parameters, rich annotations, and an output schema present, the description is largely complete for a read-only discovery tool. It covers topics, types, endpoints, QoS, and Header support, though it omits explicit routing guidance to sibling tools.

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

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

The tool has zero parameters, so the baseline is 4 under the scoring rules. There are no parameter semantics to clarify beyond what the empty schema already states.

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

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

The description uses a specific verb ("Discover") and names the resource facets (ROS topics/types, endpoints, QoS, Header support), making the tool's purpose clear. It does not explicitly distinguish itself from siblings like inspect_ros_topic or compare_ros_topics, which keeps it from 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 use this tool versus alternatives such as inspect_ros_topic for a single topic or compare_ros_topics. The discovery intent is implied, but no exclusions or routing conditions are stated.

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