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 real value beyond that: it discloses that results are 'cautious hypotheses' rather than conclusions and that findings should be persisted elsewhere, which is important framing for interpreting output.

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, followed by outputs and then the scope caveat. No filler; 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 need not be spelled out, and the description still summarizes output categories and the reliability caveat. With only two parameters (one optional) and full annotation coverage, the main remaining gap is input format guidance, which is minor.

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. It conveys that the second parameter is an optional baseline for diffing, but never states the expected encoding/format of the inputs beyond what the parameter names ('Data Hex', 'Baseline Hex') imply. Partial compensation, not full.

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 ('inspect generic bytes', 'compare a sample with a baseline') and enumerates the outputs it produces (text/integer views, entropy, changed offsets, hypotheses). It also draws a boundary against protocol identification, so an agent can tell this is low-level byte analysis rather than a device/protocol tool like its siblings. Not quite a 5 because no sibling is named directly.

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

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

Explicitly says baseline comparison is optional and clarifies the tool's role ('this is analysis, not protocol identification; save validated findings separately'), which implies when to use it and what to do afterwards. It stops short of contrasting against a named alternative tool, which keeps it from 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?

No annotations are provided, so the description carries the full behavioral burden. It does disclose the side effect (releasing an OS handle), which is genuinely useful. It does not cover idempotency, error behavior for an unknown/stale session id, or what happens to dependent device connections — significant gaps for a mutation-style teardown with zero annotation coverage.

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, zero waste, with the action and its effect front-loaded. Nothing is buried 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 the effect of closing is stated. But with no annotations and an undocumented parameter, the description should say more about failure modes and session lifecycle to be complete for a teardown 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?

Schema description coverage is 0% and the single required parameter session_id has no documentation anywhere. The description reuses the word 'session', giving a loose semantic tie, but adds no format, source, or lookup guidance for the identifier an agent must supply.

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 ('Close a previously opened interface session') and adds the concrete effect ('release its operating-system handle'). The word 'previously' implicitly pairs it with the open_interface sibling, but the sibling is never named, so differentiation requires inference.

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?

'Previously opened' implies the precondition that a session must exist, and the sibling open_interface is the obvious counterpart. However, the description never names the alternative, states what to do if no session exists, or warns about closing sessions still in use.

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

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

With no annotations, the description carries the full burden: it does disclose that 'transport access may change device state' and that iOS runs with no shell and a pinned UDID, which is genuine behavioral context beyond the schema. However, it says nothing about preconditions (pairing/authorization), timeouts or blocking behavior, or what failures look like for a tool that can poke hardware directly.

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 front-loads the general purpose, then spends one tight clause per transport, then closes with the session-reuse and state-change caveats. Dense but every clause carries distinct information; 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?

For a six-parameter, five-transport tool, this covers the operation vocabulary, options contents, session reuse, and a mutation warning, and an output schema exists so return values need not be spelled out. What remains thin is error/partial-failure behavior and the preconditions implied by the pairing 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?

Schema description coverage is 0%, so the description must compensate, and it largely does: data_hex is defined as payload bytes in hexadecimal, options is described as carrying endpoints, lengths, USB control setup fields, or argv, and session_id is sourced from open_interface. device_id and interface_id are only implied by 'target', which is the remaining gap across the six 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?

The description names a concrete verb+resource ('Perform a generic transport operation') and then enumerates the actual operations per transport (serial read/write/send/receive, USB control_read/control_write, BLE characteristic read/write, ADB execute, iOS lockdown/pymobiledevice3), which lets an agent see what it really does despite the vague name. It also ties itself to the open_interface/close_interface lifecycle, distinguishing it from those siblings, though it never names a sibling it must not be confused with.

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 clear per-transport usage context — which operations each transport supports and where endpoint/length/USB setup fields or argv belong — plus the rule to pass session_id from open_interface for a persistent session. That is strong routing guidance for the operation parameter, but there are no explicit exclusions (e.g. when to prefer inspect_device or analyze_payload over communicating).

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

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

No annotations exist, so the description carries the full burden. It does disclose a real behavioral constraint — the target must be an mDNS-advertised TLS ADB service — but says nothing about whether connection requires prior pairing/authorization, whether the device becomes persistently registered, whether it is idempotent, or how failures (stale advertisement, TLS handshake rejection) surface.

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 key qualifier (must be currently advertised) is placed where it will be read first. It is arguably too terse for a tool with an ambiguous required argument, but nothing in it 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?

An output schema exists, so return values need no explanation, but for a connection tool with zero annotation coverage and one undocumented required parameter the description leaves critical gaps: endpoint format, pairing prerequisite, and side effects on device state. An agent could not confidently invoke it without guessing.

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 the only parameter, `endpoint`, is a bare string with no format hint. The description hints the value comes from an mDNS advertisement but never says whether it is a service instance name, host:port, or a serial — a caller cannot reliably construct it from this text.

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 (Connect) and a specific resource (an Android TLS ADB service), plus a qualifying scope: only services currently advertised via ADB mDNS. This is materially clearer than the bare tool name and separates it from generic discovery tools, though it never names the sibling it must be sequenced around (pair_android_over_wifi).

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?

"Currently advertised by ADB mDNS" implies the precondition that discovery must have happened and that the service must still be live, which is useful implicit guidance. But there is no explicit when-to-use, no statement of whether pairing is a required predecessor, and no exclusion relative to pair_android_over_wifi or discover_wireless_devices.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that adapter dependency and OS access errors are reported per transport without stopping other scans, which is important failure semantics. However, it does not state whether discovery is read-only, what permissions are needed, or whether it has 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?

The description is two sentences, front-loads the core purpose, and uses the second sentence efficiently for transport restriction and error behavior. There is no redundant or empty phrasing.

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. The single optional parameter is semantically covered, and partial-failure behavior is disclosed. The main remaining gap is lack of tool-selection guidance against similar discovery/list 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?

Schema description coverage is 0%, so the description must compensate. It does so by explaining that the transports parameter optionally restricts scanning and by listing valid transport values (usb, hid, serial, bluetooth, adb, ios, network), adding meaning beyond the bare anyOf 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 — discovering connected devices — and enumerates the transport types it covers (USB, serial, BLE, ADB, iOS). It is clear in isolation, but it does not explicitly distinguish itself from the sibling discover_wireless_devices or list_known_devices.

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 discover_wireless_devices, list_known_devices, or start_device_monitor. The only usage-like detail is the optional transport restriction, which is parameter behavior rather than tool-selection 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?

No annotations are provided, so the description carries the full behavioral burden and largely fails it. It does not say whether the scan is blocking or how long it runs, whether BLE/mDNS require host permissions or an enabled radio, or whether results are cached versus live — all material for a zero-argument discovery action.

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. Every clause names a distinct transport/protocol target and nothing is redundant.

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

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

An output schema exists, so return values need no explanation, and there are no parameters to document. What is missing is the operational context: scan duration/blocking behavior, permission requirements, and how this differs from discover_devices — meaningful gaps for a discovery primitive in a large sibling set.

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 no parameters, so there is nothing for the description to disambiguate. Baseline 4 applies; the enumerated protocols in the description are a bonus rather than a necessity.

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 ("Discover") plus an enumerated set of resources: BLE/mDNS services, wireless Android ADB, and paired iOS mobdev2 services. The agent knows exactly what classes of device/transport this covers. It loses the top score because it never distinguishes itself from the near-identically named sibling discover_devices, leaving the boundary ambiguous.

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 statement of when to use this versus discover_devices, list_known_devices, or remember_discovery, and no prerequisites (e.g. that pairing must happen afterward). The agent must infer the workflow position 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, idempotentHint, destructiveHint=false, and closed-world scope, so safety is covered. The description adds that output is serialized JSON text suited to backup/sharing, which is genuine extra context, but it says nothing about permissions, whether the device must be known/paired, or size limits of the export.

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 twelve-word sentence that front-loads the verb and resource with zero wasted phrasing. The format and use case follow immediately 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?

An output schema exists, so return values need not be described, and annotations cover the safety profile. For a one-parameter read-only export, the main remaining gap is device identifier provenance, which is a moderate but not severe omission.

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

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

The single parameter device_id has 0% schema description coverage and the description never mentions it, so nothing clarifies what identifier form is expected or whether the device must first appear in list_known_devices. The description entirely fails to compensate for the 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 (export), resource (device profile), and output format (JSON text), which distinguishes it from read-oriented siblings like inspect_device or get_device_knowledge. It does not explicitly name which sibling to use instead, so it falls short of full sibling differentiation.

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

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

"for backup or sharing" implies the scenario in which to use this tool, but there is no explicit when-not guidance and no named alternative (e.g., inspect_device for read-only viewing, update_device_profile for the inverse operation). Usage must be inferred from the stated intent.

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 and idempotentHint=false, but the description adds genuinely new behavioral context: the deletion cascades to saved discoveries and experiments, and it is permanent. It does not say how a missing/unknown device_id is handled (error vs silent no-op), which is the main remaining gap for a non-idempotent delete.

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, zero waste, with the destructive nature front-loaded so the agent sees the risk before the details. Nothing to trim.

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. What's missing is small but real: how to source device_id and what happens on an unknown id, which matter for an irreversible single-parameter delete.

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 (device_id) exists and schema description coverage is 0%, so the schema gives no clue about its format or provenance. The description only implies it identifies a single device profile; it never says where to obtain the id (e.g., list_known_devices) or what form it takes.

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 ('permanently delete') and resource ('one device profile') plus the cascade scope ('its saved discoveries and experiments'), which clearly separates it from read-only siblings like list_known_devices and non-destructive ones like update_device_profile. It stops short of naming a sibling alternative, so it lands at 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?

There is no guidance on when to use this versus update_device_profile, export_device_profile, or simply leaving a device unpaired. A high-stakes irreversible operation would especially benefit from a note like 'export_device_profile first if you need to retain history' — that is absent.

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 read-only/idempotent/non-destructive profile, and the description adds real value beyond them: the policy source (UDMCP_POLICY) and the crucial semantics that an absent policy means unrestricted operation. It stops short of saying whether the returned policy is raw text or parsed rules.

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 source and the absent-policy semantics are packed into one clause each.

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-value detail is unnecessary, and the description covers the source and the meaning of an empty result. The only gap is what the policy actually controls or which operations it can restrict.

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; there is nothing for the description to disambiguate and it correctly spends no words on 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?

States a specific verb (Show) and a specific resource (the optional local policy from UDMCP_POLICY). No sibling tool deals with policy, so it is distinguishable, though 'UDMCP_POLICY' is an unexplained identifier an agent may not recognize as an environment variable.

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 infers it should call this to inspect whether a local policy constrains operations. There is no explicit when-to-use, when-not, or reference to alternatives, though the sibling set offers no competing policy tool.

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 fully covered. The description adds two pieces of real context — events are persistent (retained, so historical fetches are valid) and idempotent-by-cursor polling — but says nothing about retention window, ordering, or volume of events returned.

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 compact sentence that front-loads what is read and then gives the operational instruction. No filler, nothing to cut.

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-value explanation is not needed, and the cursor mechanic is covered. Still, an agent cannot tell from the description how far back events persist, whether they arrive in ascending order, or what limit does — gaps that matter for a polling 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 parameter burden. It explains after_id well (cursor to the last seen event id), but 'limit' is never mentioned and its default of 100 and bounds are undocumented in both places.

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

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

States a specific verb and resource — reading persistent connect/disconnect events — which is clearly distinct from every sibling (no other event-stream tool exists; start/stop_device_monitor are about monitoring, not reading history). It does not explicitly name how it relates to the monitor tools, but the resource itself disambiguates.

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?

'Pass the last event id to fetch new events' implies the polling/cursor usage pattern, which is genuinely useful guidance. However, it gives no when-to-use vs. when-not, and does not say whether this should be used instead of or alongside start_device_monitor for live event capture.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds that results include retained findings plus recent experiment history, which is useful content disclosure, but it does not say how "recent" is bounded, whether results are truncated, or what happens for an unknown device.

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 compact sentence with no filler, front-loaded with the verb. It is slightly compressed to the point of ambiguity ("all" discoveries vs "recent" history), 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?

An output schema exists, so return values need not be explained, and annotations cover safety. Still, for a read tool with one undocumented parameter, the description leaves gaps around scope, recency bounds, and behavior on invalid device IDs.

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 single required device_id, and the description never mentions it. It does not clarify whether the ID must be a previously discovered/paired device or what format is expected, so the description 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?

The description names a verb ("Read") and a resource, but the resource is expressed in internal jargon ("retained discoveries", "communication experiment history") that an agent cannot map onto concrete data without prior knowledge of this server. It also gives no signal distinguishing it from siblings like get_device_events or inspect_device, which sound related.

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 statement of when to call this versus alternatives such as inspect_device, get_device_events, or list_known_devices, and no prerequisites or exclusions. An 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 readOnlyHint, idempotentHint, non-destructive behavior, and closed-world scope. The description adds useful context that it reports availability without scanning hardware, which is a meaningful behavioral constraint beyond the 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?

The description is a single efficient sentence with no wasted words. The core action and non-scanning constraint are 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, rich annotations, and an output schema, the description provides enough context for correct invocation. Return value details are appropriately left to the output 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?

The tool has zero parameters, so there is no parameter semantics burden. A baseline of 4 is appropriate for a parameterless tool.

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 set: report runtime, adapter, optional-library, and host-tool availability. It also distinguishes the behavior from hardware scanning, though it does not explicitly name a sibling tool it replaces.

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 'without scanning hardware' implies the tool is useful when checking environment readiness without device discovery, but it does not state explicit when-to-use or when-not-to-use conditions. No sibling alternatives are named.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and open-world, so the safety profile is fully covered. The description adds the useful detail that results span device details and transport-specific interfaces/services, but says nothing about failure behavior for unknown device IDs or result size.

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 the verb and resource, with zero filler. Nothing to trim.

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, with 0% parameter coverage and many overlapping siblings, the definition leaves gaps about when this tool beats list_known_devices or get_device_knowledge and what happens with an unknown or stale device_id.

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 single parameter is documented only as 'Device Id'. The description's 'known device' phrasing implies the ID must reference a previously discovered device, which adds meaning beyond the schema, but no format, source, or error semantics are given.

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 (inspect) and resource (known device), plus the scope of returned content (device details and transport-specific interfaces/services). This distinguishes it from discovery siblings like discover_devices, though it does not clearly separate it from list_known_devices or get_device_knowledge.

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 word 'known' implies the device must already have been discovered, but the description never says when to call this versus list_known_devices, get_device_knowledge, or get_device_events. There are no explicit alternatives or exclusions, leaving the agent to infer 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description usefully clarifies that results come from the local store rather than a network scan, but adds nothing on ordering, staleness, or empty-store behavior; with an output schema present, return format need not be described.

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 key scoping fact — local knowledge database — is placed where it is read first.

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 list tool with a full output schema and complete annotations, the description covers the essentials. It could go further by noting whether entries persist across sessions or how they get there (remember_discovery), but nothing required for a correct call 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, so there is nothing for the description to disambiguate; baseline 4 applies. Schema coverage is also 100%.

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 (device profiles), and scopes it to the local knowledge database, which distinguishes it from live-scan siblings like discover_devices or discover_wireless_devices. It does not explicitly name or contrast with get_device_knowledge or inspect_device, so sibling differentiation is only partial.

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 name and by 'saved in the local knowledge database' — this is the persisted-inventory read versus live discovery — but the description never states when to prefer it over get_device_knowledge or inspect_device, nor any prerequisites for the database being populated.

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

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

With no annotations, the description carries the full burden. It discloses that the interface is persistent and returns a session id, but does not explain permissions, side effects, session lifecycle, failure behavior, or what the options parameter controls.

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 waste. It states the action, supported transports, persistence, and return value efficiently.

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 for a three-parameter connection tool with no annotations and no schema parameter descriptions, the definition omits critical context about prerequisites, options, session handling, and error conditions.

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 parameters. The description does not explain device_id, interface_id, or options, and the transport list only loosely hints at interface types without giving parameter-level 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 uses a specific verb and resource: 'Open a persistent ... interface' and names supported transports and the returned session id. It distinguishes opening from sibling tools like close_interface and communicate by implication, but does not explicitly name those alternatives.

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: open an interface to obtain a persistent session id for subsequent communication. However, the description does not state when to call this versus discover_devices, communicate, or close_interface, nor does it mention prerequisites such as prior discovery.

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

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

With no annotations, the description carries the full disclosure burden and does add meaningful context: pairing requires an owner-shown code, the endpoint must be currently advertised, and the code is passed via stdin and not persisted. It still omits post-pairing side effects and failure behavior, but the security-sensitive handling is explicitly covered.

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 three short sentences, front-loads the core operation, then adds prerequisite and security handling. Every sentence contributes useful information without 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?

The output schema covers return values, and the description covers the key prerequisite and code handling. However, for a two-parameter tool with 0% schema description coverage and no annotations, the missing endpoint format and lack of workflow sequencing leave gaps an agent must infer.

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 explain both parameters. It adds useful meaning for pairing_code as a six-digit owner-visible code and for endpoint as an ADB mDNS-advertised TLS pairing service, but it does not specify the endpoint format or give examples.

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

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

The description names a specific action and resource: pairing Android wireless debugging using a six-digit code. It distinguishes itself implicitly from connect_android_over_wifi by focusing on the pairing step and the ADB mDNS TLS pairing prerequisite.

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 clear prerequisite: the endpoint must currently be advertised by ADB mDNS as a TLS pairing service. However, it does not explicitly route the agent through discover_wireless_devices first or name connect_android_over_wifi as the follow-up step.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Append' implies a mutation, but it does not explain permissions, reversibility, duplicate handling, or what happens to existing profile knowledge when new content is appended.

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 wasted words. It is efficient, though its brevity contributes to under-specification elsewhere rather than being a flaw of conciseness itself.

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 five-parameter mutation tool with no annotations and 0% schema description coverage, the description is too sparse. An output schema exists, so return values need not be explained, but the input semantics and behavioral implications are largely 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%, and four of the five parameters (device_id, category, content, source) receive no semantic explanation. The description adds meaning only for confidence by naming two accepted values, but that is far short of compensating for the undocumented 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?

The description states a specific verb and resource: append knowledge to a device profile. It is distinguishable from retrieval siblings like get_device_knowledge, but does not explicitly contrast with update_device_profile or forget_device.

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 no guidance on when to use this tool versus get_device_knowledge, update_device_profile, or other knowledge-management siblings. The confidence values are mentioned, but not the conditions for choosing between them or when appending is appropriate.

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

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

No annotations are provided, so the description carries the full burden. It hints that monitoring is a server-side background activity ('in this server') but says nothing about whether the call returns immediately or blocks, what happens if monitoring is already running, whether it is idempotent, or how events surface (presumably via get_device_events).

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

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

One front-loaded sentence with no filler and the scope stated up front. It is efficient, though the terseness is part of why behavior and parameter details are missing.

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 for a stateful background-process tool with no annotations and an undocumented interval parameter, the description omits lifecycle, side effects, and event-retrieval context that an agent needs before starting a monitor.

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 parameter interval_seconds has 0% schema description coverage (only a default of 5), and the description never mentions polling frequency or its units/valid range. With one undocumented parameter the description should compensate, and it does not.

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 ('Start') and a well-scoped resource ('automatic USB, HID, serial and ADB connect/disconnect monitoring in this server'), which clearly separates it from one-shot siblings like discover_devices. It does not explicitly name stop_device_monitor or get_device_events as counterparts, so sibling differentiation is implied rather than stated.

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?

'Automatic ... monitoring in this server' implies continuous background watching as opposed to a one-off discover_devices call, so the usage context is inferable. However, there is no explicit when-to-use/when-not, no mention of pairing with stop_device_monitor, and no statement about how observed events are retrieved.

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

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

With no annotations, the description carries the full behavioral burden and falls short. It does not say whether the call is idempotent, what happens if monitoring was never started, whether in-flight or queued device events are discarded, or whether the change is reversible without restarting.

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 waste, and the operative verb is front-loaded. It is lean to the point of under-specification rather than verbose, but nothing needs trimming.

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 there are no parameters to document. What is missing is state-transition context for a mutating control call: the no-op/precondition behavior and the effect on event collection, which matter given the absence of annotations.

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. There is nothing extra the description could meaningfully add about inputs, and it correctly does not invent any.

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 ('Stop automatic device connection monitoring'), so the effect is unambiguous. It does not explicitly name its counterpart start_device_monitor, which is the only other monitoring-control sibling, 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?

The word 'Stop' implies this only applies when monitoring was previously started, which is a reasonable implied usage context. However, there is no explicit when-to-use, no prerequisite check, and no mention of start_device_monitor or get_device_events as related tools.

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

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

No annotations exist, so the description carries the full burden, and it delivers the most important behavior: identity and hardware are merged while interfaces are replaced wholesale, with fingerprint and transport immutable and a stated reason (they identify the physical target). Missing are error behavior for an unknown device_id and any permission/auth requirements, but the merge-vs-replace distinction is genuinely high-value disclosure a caller could not infer.

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 scope, then the merge/replace rule, then the immutability constraint. No filler and each sentence carries 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?

The output schema covers return values, and the description covers mutation semantics, merge behavior, and immutability — the core gaps for an unannotated write tool. Remaining shortfall is failure modes (unknown device, invalid keys inside 'updates') and permission requirements, which matter for a mutation with no annotations.

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% and 'updates' is an unconstrained additionalProperties object, so the description must compensate, which it largely does by naming the four accepted categories and explicitly listing the two keys that must not be sent. It still leaves the internal field names of the identity and hardware objects unspecified.

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 (edit) and a precise resource (a saved device profile), then enumerates the editable facets: name, identity, hardware metadata, interface list. That is enough to separate it from inspect_device, export_device_profile, forget_device, and the discovery siblings, though it never names a 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?

Usage is implied by the mutation framing and by the exclusion of fingerprint/transport fields, which tells the agent this is not the tool for re-identifying a device. There is no explicit 'use this when…' or 'for X use Y instead', and no prerequisites about the profile having been saved or the device being known.

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