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

Annotations already establish readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds real value beyond that: it discloses that a SHA256 is computed and recorded, and it explicitly lists what the inspection does NOT cover, preventing an agent from over-trusting the result as a validation gate.

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 zero filler; the positive capability is front-loaded and the negative scoping follows immediately. 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?

For a one-parameter, read-only inspection tool with no output schema, the description is nearly sufficient: it states the input domain, the computed artifact (SHA256) and the exclusions. It could still be more complete about what metadata is returned and where the hash is recorded, but no critical gap prevents 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% for the single 'filename' parameter, so the description carries some of the burden: it implies a local file reference and enumerates accepted asset kinds (COLLADA, glTF, GLB, texture). It still says nothing about path form, relative-vs-absolute resolution, or whether the file must already exist, so it only partially compensates.

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 (inspect) plus a concrete resource (local COLLADA/glTF/GLB/texture export) and a stated effect (records its SHA256). The second sentence draws explicit boundaries against adjacent concerns like upload eligibility, LOD quality and land impact, which separates it from siblings such as mesh_upload_status or mesh_preview_camera.

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 clear when-not ('not upload eligibility, LOD quality, land impact or in-world appearance'), which implicitly scopes usage to a pre-upload metadata/hash check. However it never names an alternative tool or states prerequisites such as where the local file must reside or whether the path is absolute, so routing guidance is only implied.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds only the read targets (autopilot progress, position) and says nothing about polling behaviour, whether it blocks, or how often progress updates, which are the meaningful unknowns 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?

A single front-loaded sentence with no filler; it names both return values in the order the tool name implies. Nothing is wasted.

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

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

For a zero-parameter read tool the description is nearly adequate, and the annotations carry the safety picture. However, with no output schema and a near-identical sibling (avatar_position), the description never clarifies what 'status' returns beyond position, leaving the agent to guess at the progress payload.

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. The description correctly implies no input is required, and there are no parameters whose meaning could be obscured.

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 two specific resources ('autopilot progress and current avatar position'), which is well above tautology. It does not differentiate from the sibling avatar_position, so an agent cannot tell from the description alone why it should call this instead of that.

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, no mention of prerequisites such as needing an active control session, and no reference to alternatives like avatar_position despite the obvious overlap. Usage must be inferred entirely from the name.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, covering the safety profile. The description adds the useful detail that data comes from the viewer, but discloses nothing about return format, update cadence, or whether the avatar must be logged in — a moderate gap given no output schema.

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

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

A single front-loaded sentence with no filler. It leads with the verb and resource and adds only the data source, which 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?

For a zero-parameter read tool with annotations covering safety and no output schema, the description says what is read and from where. It is nearly complete, though it could note the coordinate/orientation format returned, since no output schema documents it.

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 clarify; baseline 4 applies. The empty schema is consistent with the description.

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 ('avatar position/orientation') plus the data source ('from the viewer'). It is distinguishable from most siblings, though it doesn't explicitly separate itself from avatar_movement_status, which an agent might confuse with it.

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 conditions, and no mention of alternatives such as avatar_movement_status. The agent must infer context entirely from the tool name.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false and openWorldHint=true, so the agent knows this mutates state in an open world. The description adds what specifically is cancelled (automatic movement) and that a resulting state is returned, which is useful given there is no output schema, but it does not explain reversibility, permissions, or what the returned state contains.

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 that is front-loaded with the action and carries no filler. Every clause earns its place by covering both the mutation and the read-back.

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

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

With no output schema, the description should explain what 'resulting state' means (e.g. final position, movement status). It gestures at the return value but leaves its content unspecified, and it omits any note on preconditions or side effects for a destructive-flagged 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?

The tool takes zero parameters, so there are no parameter semantics to document; the baseline of 4 applies. The description correctly implies it is invoked without arguments.

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 ('cancel') and resource ('automatic movement') plus a return side-effect ('read its resulting state'). It is clear what the tool does, but it does not distinguish itself from the closely related sibling avatar_movement_status, which an agent would need to tell apart.

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 explicit when-to-use guidance. The agent must infer from the name that this is a stop command, and the description never mentions alternatives such as avatar_walk_to or avatar_movement_status, nor any precondition (e.g. that movement must be active).

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 safety profile (readOnly=false, destructive=true, openWorld=true), yet the description adds a genuinely important behavioral fact not in the annotations: the call is not synchronous success, so the agent must poll avatar_movement_status and verify. It omits whether an in-progress walk is cancelled or whether movement can fail outright.

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

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

Two short sentences, front-loaded with the action, followed by the essential caveat. Nothing redundant; every clause carries information.

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

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

For a mutation tool with no output schema and zero parameter documentation, the description covers the action, the follow-up verification step, and the success caveat, but leaves key behaviors unexplained: effect on an existing walk, meaning of allow_flying and stop_distance, and whether failure is signalled at call time.

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, so the description must carry the burden. It clarifies that global_position is a GLOBAL (not local) coordinate, which is meaningful next to local_mesh tools, but allow_flying and stop_distance are never mentioned in either the schema or the description.

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 (walk) and resource (avatar) plus the target frame ('GLOBAL coordinates'), which cleanly separates it from siblings like avatar_stop, avatar_position, and local_mesh_* tools. It stops short of explicitly naming an alternative, but the action is unambiguous.

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

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

It supplies real usage context: poll avatar_movement_status and verify position, and explicitly warns that a return 'is not pathfinding success'. That is a clear directive about what to do after calling. There is no explicit when-not-to-use guidance (e.g. while already walking).

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 declare destructive and open-world behavior. The description adds that it returns to viewer camera behavior (not an exact saved pose), clarifying the resulting state. It does not detail permissions or reversibility, but adds useful context beyond 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 concise sentences, front-loaded with the action and a key clarification, with no wasted words.

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

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

For a no-param tool with no output schema and annotations covering safety, the description is nearly complete. It could mention idempotency or required prior state, but is adequate.

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

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

Zero parameters, so baseline is 4 per rules. No parameter descriptions are needed.

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 (release) and resource (scripted camera control), and distinguishes from a saved manual camera pose, which helps differentiate from siblings like camera_set.

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

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

Implies use after scripted control is active, but does not explicitly state when to use this versus alternatives (e.g., camera_set, control_release). No prerequisites or exclusions 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=false, destructiveHint=true, and openWorldHint=true, so the mutation and open-world profile is covered. The description adds the 'fixed camera' framing and the REGION coordinate system, but does not say it replaces/overrides the current view state or interact with camera_release, which is the main behavioral gap.

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 the action and coordinate frame front-loaded and no filler. The second sentence is advisory rather than redundant, so it earns its place, though it is slightly tangential to invocation.

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 low-complexity two-parameter tool with annotations present and no output schema, the safety and coordinate-frame context is adequate. However, with 0% parameter coverage and no return/blocking behavior described, an agent still lacks enough to construct valid position/focus values confidently.

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

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

Schema description coverage is 0% for two required array parameters, so the description carries the whole burden. It supplies only the coordinate frame ('REGION coordinates'); it never explains that position/focus are numeric arrays, their expected length/order (e.g., x,y,z), or units, leaving the parameters effectively unexplained.

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 ('Set') and resource ('a fixed camera and focus') plus the coordinate frame (REGION coordinates), which separates it from camera_release and the preview tools. It is clear, though it never names a sibling to differentiate against.

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?

'Viewport capture is needed to verify composition' implies the follow-up workflow (set the camera, then capture), which is useful implied context. There is no explicit when-to-use/when-not guidance relative to siblings like camera_release, capture_orbit, or mesh_preview_camera.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true and destructiveHint=false, so safety is covered. The description adds the useful nuance that this re-populates the agent's dynamic tool list rather than reader state, but does not say whether the refreshed tool set replaces the current one or how failures 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?

One compact sentence that front-loads the discovery purpose. The semicolon-joined second clause is slightly redundant with the first but still earns its place by naming the concrete effect on tool discovery.

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

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

With no parameters and no output schema, there is little else the description must cover. It adequately conveys the action and its effect on tool availability, though it could note whether the refresh is awaited or how results are surfaced.

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 implies no arguments are needed.

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: discover all APIs and operations exposed by the viewer, and refresh dynamic MCP tool discovery. It is clear what the tool does, though it does not explicitly distinguish itself from the similarly named sibling viewer_api_inspect.

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?

'Refresh' implies the situation (after the viewer's capabilities change), but the description never says when to call this versus viewer_api_inspect or other discovery/inspection siblings, nor whether it should be run proactively. Usage is only inferable.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description usefully reinforces the server-local scope of the manifest but says nothing about failure behavior for a missing filename or what a manifest contains.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficiently sized, though its brevity is partly a symptom of under-specification rather than disciplined editing.

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

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

With no output schema, the description carries the burden of explaining what a manifest read returns, and it does not. Combined with an entirely undescribed filename parameter, the definition is too thin for an agent to call this tool confidently.

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

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

Schema description coverage is 0% and the single required parameter, filename, is undocumented. The description does not clarify whether this is a bare name, a path, an extension requirement, or where the server stores manifests, so it fails to compensate for the 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 gives a clear verb-resource pair ("Read a saved capture manifest") and scopes it to manifests "created by this server." It does not name or distinguish itself from siblings such as capture_orbit or snapshot, but the purpose is unambiguous.

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

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

There is no statement of when to use this tool, what precondition must hold, or what the alternative is. The phrase "created by this server" is a scope constraint rather than usage guidance, leaving the agent to infer when a manifest read 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?

Annotations already flag destructiveHint=true, readOnlyHint=false, and openWorldHint=true. The description adds real value beyond them by disclosing that it takes scripted camera control and 'Releases scripted camera in finally' and that it writes a manifest – side effects the annotations do not spell out. It still does not explain what gets destroyed or the resulting files/format.

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

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

Three sentences, front-loaded with the core action and output, no filler. The trailing 'Caller must identify...' sentence is somewhat dangling but still earns partial place by flagging a decision.

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

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

For a 7-parameter, 0%-coverage, no-output-schema tool, the description is too thin: it never documents the parameters or the manifest's contents. It gives a decent behavioral sketch (camera release, saving) but leaves an agent unable to call it correctly without guessing parameter meanings.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate and mostly does not. 'REGION-coordinate focus' loosely maps to the required 'focus' array, but label, radius, object_id, evidence_kind, height_offset, and views are 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 verb (capture) and resource (orbit views), plus the output artifact (a manifest), around a 'REGION-coordinate focus'. It distinguishes itself from the many nearby camera/preview siblings by naming the orbit-view construct, though it does not explicitly contrast with snapshot or mesh_preview_camera.

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 line 'Caller must identify whether the subject is local preview or a server asset' hints that a precondition matters but never says which parameter or condition selects the branch, nor names an alternative tool. No when-to-use vs snapshot/mesh_preview_camera guidance 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 readOnlyHint=true, destructiveHint=false, so the safety profile is covered. The description still adds value by clarifying that checking status does not log in and does not mutate the viewer, which distinguishes a passive probe from a connect/login action. It does not disclose what the response contains, but the extra side-effect boundary earns credit 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?

Two short sentences, the core purpose front-loaded and the side-effect caveat second. Every clause earns its place 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?

For a zero-parameter, read-only probe with annotations covering safety, the description is essentially complete. The one gap is that no output schema exists and the description does not say what the check returns (e.g., a connected/disconnected boolean), so an agent cannot fully anticipate the result.

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 per the rubric the baseline is 4. There is nothing parameter-wise the description could add, and it correctly does not invent any inputs.

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

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

The description names a specific verb and resource: checking whether the local Firestorm LEAP helper is connected. That is much more concrete than a tautology, but it does not differentiate itself from status-like siblings such as local_mesh_status or avatar_movement_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?

Usage is only implied: an agent can infer this is a preflight connectivity check, but no when-to-use or when-not condition is stated. The clause 'Does not log in or change the viewer' gives a partial negative scope by ruling out side effects, which is better than nothing but not a routing rule.

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

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

Annotations already flag destructive/openWorld/not-readOnly, so the safety bar is partly met; the description adds genuinely useful behavioral context beyond that: other clients can still read status/events, the lease expires and must be renewed, release belongs in finally, and human input remains possible. Only the failure mode when the lease is contended is left undisclosed.

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

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

Front-loaded with the core action in one short sentence, followed by three compact operational clauses. Every clause carries information; no padding, though the terse grammar slightly sacrifices 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?

No output schema exists, and the description does cover the essential operational story (acquire, renew, release, read parallelism). But for a mutating lease tool it omits what acquiring returns and whether acquisition blocks or fails when another client holds the lease, which are needed to call it correctly.

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

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

Schema description coverage is 0% and neither optional parameter is documented in the schema. The description hints that 'seconds' relates to expiry ('renew before expiry') but never explains the label field, the seconds unit/default, or what the value controls, so it 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 and resource: 'Acquire a workflow control lease.' An agent can distinguish it from the sibling control_release (the acquire/release pairing is clear). It stops short of explaining what a 'control lease' actually grants, so it is clear but not fully self-differentiating.

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 lifecycle guidance ('Renew before expiry and release in finally'), which implies ongoing use and points toward control_release. However, it never states when to acquire versus not, nor what happens if the lease is already held by another client, leaving the core usage decision 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 destructiveHint=true, readOnlyHint=false, and openWorldHint=true, so the safety profile is covered by structured data. The description adds only that the released lease is this client's (scoped ownership); it says nothing about idempotency, error behavior when no lease is held, or side effects on other clients.

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 word carries meaning and nothing is repeated from the title or annotations.

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

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

For a zero-parameter tool with annotations covering the mutation/destructive profile and no output schema, the description is nearly sufficient. Only minor gaps remain, such as what happens if the caller holds no lease.

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 trivially complete, so there is nothing for the description to disambiguate. Baseline 4 applies.

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

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

Specific verb+resource: "Release ... exclusive control lease" clearly states what the tool does. It pairs naturally with the sibling control_acquire, giving an agent enough to distinguish the two without opening either schema, though it does not name the 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 only implied: the phrase "this client's ... lease" suggests the caller must already hold a lease, and the sibling control_acquire implies the acquire/release pairing. There is no explicit when-to-use, when-not-to-use, or alternative 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 a safe read (readOnlyHint=true, destructiveHint=false), so the bar is lower. The description adds genuinely useful behavior beyond the structured fields: the 'dropped' flag signals buffer overflow and missing events must not be inferred. It does not explain polling cadence or return shape, keeping it from a 5.

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

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

Two sentences, zero waste, and the core read semantics are front-loaded before the buffer-overflow caveat. 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?

For a read-only, one-parameter tool with annotations covering safety and no output schema, the description covers purpose, cursor semantics, and the dropped-flag overflow behavior. It is nearly complete, though it omits guidance on how the event stream relates to events_subscribe.

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 'after' parameter, so the description must compensate. Calling it a 'cursor' clarifies that after is an opaque continuation token rather than a plain index, but it adds no format or default details beyond that.

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: 'Read subscribed viewer events after a cursor.' The word 'subscribed' implicitly ties it to events_subscribe/events_unsubscribe, so an agent can place it in the family. It stops short of naming the siblings explicitly, so it is clear but not fully differentiated.

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 explicit statement of when to call this versus events_subscribe, events_unsubscribe, or any polling alternative. The phrase 'after a cursor' weakly implies incremental polling, but no conditions, prerequisites, or exclusions 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?

Adds genuine behavioral context beyond the annotations: events are bounded and stay local until read, which describes buffering and locality. However, it says nothing about the destructiveHint=true / openWorldHint=true profile — notably whether subscribing replaces or discards an existing subscription or buffered events, which is exactly what an agent needs given the destructive flag.

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

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

Two tight sentences, front-loaded with the verb and resource, with the buffering caveat second. No filler or redundancy.

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

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

A one-parameter, no-output-schema tool; the description covers what it does, example inputs, and event lifecycle behavior. The main gap is how subscribed events are retrieved (events_read) and what a subscription costs, but the core is adequately covered.

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 carries the burden — and it does, supplying two concrete valid values for the otherwise opaque 'source' parameter. It stops short of listing all valid stream names or the format, but the examples materially compensate for the undocumented schema.

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

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

States a specific verb+resource ('Subscribe to a named viewer event stream') and gives concrete stream examples (StartupState, LLAutopilot). It implicitly separates itself from events_read and events_unsubscribe, though it never names those siblings 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?

No when-to-use, prerequisites, or named alternatives are given. The pairing with events_read/events_unsubscribe must be inferred entirely from sibling names.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, and openWorldHint=true, telling the agent this is a mutating, potentially destructive action. The description adds no behavior beyond the name: it does not say whether unsubscribing cancels an existing stream, what happens to buffered events, or whether it is idempotent. With annotations covering the safety profile, the description still offers negligible added context for a destructive 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?

One short sentence with no wasted words, but it is sparse to the point of under-specification rather than tight conciseness. Front-loading is fine given how little is said.

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

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

For a destructive, single-parameter tool with no output schema and 0% schema description coverage, the description omits everything an agent needs: what 'source' means, subscription preconditions, and any effect of unsubscribing. Only the safety-oriented annotations partially compensate.

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 'source' is completely undocumented. The description never explains what 'source' identifies, its format, or valid values (no enum), so an agent has no basis to supply a correct 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 states a specific verb (stop subscribing) and resource (viewer event stream), which is unambiguous and clearly the inverse of the sibling events_subscribe. It stops short of explicitly naming that sibling or the read counterpart events_read, but an agent can identify the operation without opening the schema.

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

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

There is no guidance on when to unsubscribe versus when not to, no mention of the paired events_subscribe tool, and no preconditions (e.g., must be currently subscribed). Usage must be inferred entirely from the name.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered without the description. The description adds that results include XUI files, which hints at the return shape, but says nothing about ordering, pagination, or whether the viewer must be connected.

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

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

A single front-loaded sentence with the resource stated first and no filler. Every word 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?

For a zero-parameter, read-only listing tool with no output schema, the description covers what is enumerated and hints at the payload (XUI files). It is essentially complete, with only minor gaps around result format and prerequisites.

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 per the baseline there is nothing for the description to disambiguate beyond what the empty schema already conveys. No parameter meaning is missing.

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 (registered viewer floaters) and even mentions the associated XUI files, so the agent knows it is a discovery/enumeration call rather than an action. It does not explicitly contrast itself with the sibling floater_open, so an agent must infer the read-vs-open distinction from the names alone.

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

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

No explicit when/when-not statements or named alternatives, but the usage is strongly implied: this is the enumeration step that would precede floater_open. The agent can infer the workflow, yet nothing in the text confirms it or rules out other cases.

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 declare destructiveHint=true and openWorldHint=true, meaning this can mutate viewer state in unpredictable ways, but the description reads like a benign open-and-check. It never discloses what is destroyed or why the operation is destructive, so it undersells the risk the annotations flag.

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

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

A single tight sentence with the action front-loaded. It is efficient, though bundling the visibility check into the same sentence without explaining its relevance is slightly muddy.

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

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

No output schema and no annotation-adjacent explanation; for a destructive, open-world tool with one fully undocumented parameter, the description leaves an agent unable to predict effects, return values, or failure modes.

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 sole parameter 'name' is undocumented in both schema and description. The phrase 'registered viewer floater' hints that name refers to a registered floater identifier, but format, source of valid names, and matching rules are absent.

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 (Open) and resource (registered viewer floater), and adds a secondary effect (visibility check). It doesn't differentiate itself from sibling 'open'-style tools like local_mesh_open, mesh_upload_open, or floater_list, and the term 'floater' is left unexplained.

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

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

No guidance on when to use this versus floater_list or the other open tools, no prerequisites (must the floater be registered/available?), and no mention of what happens if the name isn't found.

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

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

The description is consistent with annotations (destructiveHint=true is explained by saving a diff PNG), and the caveat that metrics don't establish semantic/material correctness is genuinely useful context beyond the annotations. However, it omits where the file is written, whether an existing file is overwritten, and what the returned metrics actually are.

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

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

Two sentences, front-loaded with the core action and followed by the key caveat. Every clause earns its place 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?

For a two-input tool with no output schema, the description covers purpose, output artifact, and a meaningful limitation, which is reasonable. It still leaves parameter roles and the nature of the 'metrics' it references unexplained, so it is not fully complete.

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

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

Schema coverage is 0% with two undocumented string params. The description contributes only the 'same-size' constraint and never maps reference vs observed roles, so an agent gets little help on what each argument should contain.

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

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

The description states a specific verb (compare), the exact resource (two same-size images), and the output side effect (save an absolute-difference PNG). No sibling in the list performs image comparison, so an agent can immediately distinguish this tool from the viewer/UI/capture tools.

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

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

It implies usage through the 'same-size' prerequisite and adds a caveat about metrics, but gives no explicit when-to-use/when-not guidance or workflow context. Adequate implied guidance, no real selection criteria.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value beyond that by enumerating excluded side effects ('Does not rez, purchase or upload anything') and disclosing recursive traversal and metadata return, which the annotations do not convey.

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

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

Two tight sentences: the primary action is front-loaded and the scope caveat follows. Every clause carries information 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?

There is no output schema, but the description notes the return ('item metadata'), which is helpful. However, for a four-parameter tool with zero schema documentation, the total absence of parameter guidance leaves notable gaps 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% across four parameters (folder_id, name, limit, asset_type), and the description explains none of them. With a name like 'folder_id' the target folder is implied, but the meaning of 'name,' what 'limit' caps, and valid 'asset_type' values are undocumented anywhere.

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 ('Search a specific inventory folder recursively') plus the return shape ('item metadata'). It is clearly distinguishable from viewer/UI siblings, though there are no other inventory tools to differentiate against.

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

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

The description implies use ('search a specific inventory folder recursively') and scopes effort via 'specific folder,' but gives no explicit when-to-use, when-not, or alternatives. Adequate but with visible gaps.

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

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

The description adds useful behavioral context beyond the annotations: the call mutates configuration and 'returns the previous settings for restoration.' This is a real addition not present in the destructive/openWorld hints. However, it omits persistence scope and what exactly the destructive aspect entails.

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

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

Two short, front-loaded sentences with no filler. The mutation and its return value are stated 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?

A destructive, mutating tool with no output schema and 0% parameter documentation needs more than two sentences. It says nothing about persistence, required auth, scope of the reload, or return shape, leaving significant gaps.

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

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

Schema description coverage is 0%, so the description carries the full burden, but it never explains either parameter. 'enabled' is inferable from the tool name, but 'seconds' (presumably the polling interval) is left entirely undefined.

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 ('Set local mesh automatic reload') with a concrete effect ('so Blender exports can refresh in the viewer'). It is clearly distinguishable from read-only siblings like local_mesh_status, but it does not explicitly contrast 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?

No when-to-use guidance, no mention of prerequisites, and no alternatives named. The agent learns what the tool does but nothing about when to prefer it over local_mesh_status or local_mesh_open.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and openWorldHint=true. The description adds a genuine caveat beyond the annotations (local replacements are viewer-only and do not prove server upload), but it never explains why the operation is flagged destructive or what happens after the panel opens.

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 waste; the action is front-loaded and the scope caveat follows immediately. Nothing is 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?

For a zero-parameter, no-output-schema action tool, the description covers what opens and one important behavioral caveat. It is nearly complete, with only the destructive flag's rationale left unexplained.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing for the description to compensate for on the schema side.

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 (Open) and resource (Firestorm's Local Mesh panel), so the action is unambiguous. It does not explicitly distinguish itself from siblings like local_mesh_status, but the panel-open semantics are clear from the verb.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no sibling (e.g., local_mesh_status, mesh_upload_open) is named as an alternative. The reader must infer the use case from the single-sentence description.

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 and destructiveHint=false, so safety is covered. The description adds genuinely useful context beyond that: the returned data reflects a local preview rather than an uploaded/simulated asset, which prevents the agent from misinterpreting stale or provisional values. It stops short of describing freshness or reload behavior (local_mesh_auto_reload exists).

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

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

Two short sentences, front-loaded with the read target followed by the scope caveat. No padding, though the second sentence is terse enough that its intent ('not a simulator upload') requires a little unpacking.

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

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

With no output schema, the description carries the burden of indicating return content; it names 'selected item/object and displayed import log' but does not say what shape that data takes or what an empty selection looks like. For a low-complexity zero-param status read this is adequate but not fully self-sufficient.

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 trivially complete, so the baseline is 4. There is no parameter semantics for the description to add meaning to.

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

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

States a specific verb (read) and resource (Local Mesh's selected item/object and its import log), so the agent knows exactly what state is being retrieved. The closing clause distinguishes it from the simulator-upload siblings, though it does not directly differentiate it from local_mesh_open or mesh_upload_status by name.

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 bounds the domain ('this is local preview evidence, not a simulator upload'), which implicitly tells the agent when this is the right source of truth. However, it never states when to call this vs local_mesh_open or mesh_upload_status, so the routing decision 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 it is a mutating, destructive, open-world operation, so the description need not restate safety. It adds real behavioral context: fractional bounds (-0.45..0.45), sign semantics for vertical, and the important limitation 'No exact pose readback or restoration', which is consistent with destructiveHint=true.

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

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

Five compact sentences, front-loaded with the purpose before constraints. Every clause carries information, though the clipped telegraphic style ('Capture to verify') is terse to the point of being slightly cryptic.

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 3-param tool with no output schema and full annotation coverage, the description supplies purpose, bounds, sign conventions, a mode constraint, and the readback/restoration limitation. The only material gap is that pan and orbit mode behavior is never described.

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 carry parameter meaning. It documents vertical ('positive zooms in'), horizontal ('zoom needs horizontal=0'), and the numeric bounds, but leaves the pan and orbit modes of the 'mode' enum unexplained despite the enum existing in the schema.

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

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

States a specific verb and resource ('Drag the mesh uploader's preview camera') and immediately scopes it against the alternative ('world camera stays unchanged'). An agent can distinguish this from camera_set, camera_release, and capture_orbit without opening any schema.

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

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

Offers an implicit workflow cue ('Capture to verify') and a constraint for one mode ('zoom needs horizontal=0'), but never states when to choose this tool over siblings like camera_set or capture_orbit. 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?

With destructiveHint=true and openWorldHint=true declared, the annotations carry most of the safety signal, and the description usefully adds what the tool does NOT do (no submit, no fee authorization). It still doesn't disclose what viewer state changes when the preview workflow opens, leaving some tension with a destructive annotation on an 'open preview' 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?

Two short sentences with the positive behavior front-loaded and the exclusion second; every clause earns its place 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?

For a zero-parameter, no-output-schema tool this is adequate but thin: it doesn't say what the workflow produces, what the agent should do after opening it, or how it relates to mesh_upload_status. Complete enough to invoke, incomplete for planning.

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 are no parameter semantics to document; the baseline for a parameterless tool is 4. Nothing in the description misrepresents or omits an input.

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 plus resource ('Open the standard mesh upload preview workflow'), which is more precise than the bare tool name. It doesn't name the sibling tools that could be confused with it (mesh_upload_status, local_mesh_open), so it falls short of a 5.

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

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

The negation 'Does not submit an upload or authorize an upload fee' implies the boundary between this tool and the actual submission step, which hints at when it is appropriate. However, it never states when to call it (e.g., before a submit step) or routes the agent to mesh_upload_status for follow-up, so the guidance is only implicit.

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, non-destructive profile, yet the description adds genuinely non-obvious traits: the readback is non-atomic and quote freshness and file bytes are unverified. That is real caveat information an agent cannot infer from annotations or schema. It stops short of saying what happens when no importer is open.

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, zero waste: the returned field list comes first, then the two behavioral caveats. Every clause carries information the 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?

With no output schema, the description must carry the return-value burden, and it enumerates the returned fields plus their reliability limits. It is nearly complete; it omits the shape of the result and the behavior when no importer dialog exists.

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. The description correctly implies a nullary read against the current importer state, and no parameter documentation is required.

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

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

Specific verb+resource: 'Read importer LOD files/counts, physics, dimensions, warnings, weights, displayed fee and visibility' tells the agent exactly what state is inspected. 'Does not calculate or upload' implicitly separates it from mesh_upload_open. It never names a sibling explicitly, so differentiation is inferential 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?

Usage is implied rather than stated: checking pre-upload importer state, and the note that it 'does not calculate or upload' hints you need a different tool for those actions. There is no explicit when-to-use/when-not-to-use guidance or named alternative such as mesh_upload_open or local_mesh_status.

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

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

Annotations already declare destructiveHint=true and openWorldHint=true. The description adds useful context beyond them: it checks ownership/filename, requires confirmation of which workflow opened the dialog, and warns to verify the import afterward. However these hints stay cryptic and never explain consequences or permissions.

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 front-loaded sentences, each adding a distinct constraint (scope, post-action check, platform limitation). No filler, though the phrasing is clipped enough to verge on cryptic.

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

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

With no output schema, no annotation detail beyond hints, and 0% schema description coverage, the description leaves key facts unstated: what dialog_id refers to, what value is returned, and what the destructive selection actually triggers.

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 carries the full burden. It only alludes to 'filename' (checked after selection) and says nothing about dialog_id, which is required and presumably comes from a prior dialog-listing call.

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

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

States a concrete verb and resource: selecting a file in a Windows Firestorm Open dialog. That distinguishes it from generic siblings like native_file_dialogs (discovery) and ui_click, though it never names those siblings 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?

'freshly discovered' and 'Other platforms need manual selection' imply this follows a dialog-discovery step and is Windows-only, but neither condition nor the alternative tool is stated outright. Usage is inferable 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, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful scope and failure-mode context beyond the annotations: dialogs must belong to this Firestorm installation, only English common dialogs are recognized, and unsupported layouts fall back to manual selection.

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

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

Two tightly written sentences: the first front-loads the purpose and scope, the second states the limitation. Nothing is wasted and the ordering is good.

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

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

For a zero-parameter, read-only listing tool with no output schema and cover from annotations, the description covers purpose, scope, and a failure mode. It stops short of connecting the listed dialogs to the sibling selection tool, which would make it more complete.

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

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

The tool takes zero parameters, so there is nothing for the description to clarify beyond the schema. Per the baseline for parameterless tools, a 4 is appropriate.

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

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

The description states a clear verb and resource: 'List recognized Windows Open-file dialogs owned by this Firestorm installation.' It is specific enough to separate this listing tool from a file-choosing sibling, but it never explicitly names or differentiates itself from native_file_choose or any other sibling.

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

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

There is no explicit 'use this when' or 'prefer this over X' guidance. The caveat 'English common dialogs only; unsupported layouts require manual selection' implies a fallback path, which is useful context, but the obvious sibling relationship with native_file_choose is not addressed.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds no behavioral context beyond that: it does not say what happens for an unknown key, whether errors are raised or a default returned, or what the response looks like.

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 scope/default information comes first and every clause carries meaning.

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

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

For a simple two-parameter read with annotations carrying the safety profile and no output schema, the description is minimally adequate. It still leaves the key/group semantics and failure behavior unexplained.

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

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

Schema description coverage is 0%, so the description must compensate, yet it only hints that 'key' names a viewer setting and repeats the 'Global' default that the schema already encodes. The valid key namespace, group values, and format 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 + resource (read a named viewer setting), clearly distinguishing it from the write-side sibling setting_set. It is unambiguous what the tool does, though it never names or contrasts the 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as setting_set or the floater/ui_* tools. Usage is only implied by the verb 'Read'.

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

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

Annotations already declare destructiveHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuinely new behavioral context: the call returns before/after readback (so results can be verified) and that persistence across restarts is inconsistent. It still does not say why the call is destructive or whether changes are reversible.

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

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

Two short, front-loaded sentences with no filler; the primary action and return behavior lead. The qualifier 'Some settings' is deliberately vague but not wasteful.

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

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

For a destructive mutation with no output schema and no parameter documentation, the description leaves major gaps: valid key namespace, group semantics, and the consequences/reversibility of the destructive change. The readback and persistence notes help but are not enough to call this complete.

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

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

Schema description coverage is 0% for three parameters, and the description says nothing about key, group, or the meaning/validity of value. The 'some settings persist' clause hints that key identity matters but gives no syntax, valid key names, or group semantics, so it fails to compensate for the empty schema.

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

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

States a specific verb+resource ('Change a viewer setting') and adds the observable outcome ('return before/after readback'), making it distinguishable from the sibling setting_get. It does not explicitly name a sibling, but the write-vs-read split is obvious from the name pairing.

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 explicit when-to-use or when-not-to-use guidance and no named alternative (e.g. setting_get for reading). Usage is only implied by the verb 'Change', which an agent must infer.

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

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

Annotations already cover the safety profile (readOnly, non-destructive, openWorld), so the bar is lower. The description adds real value beyond them by disclosing the return artifacts (MCP image plus saved PNG and hash) and an important semantic caveat that the capture does not prove upload or visibility to others.

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

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

Two tight sentences, front-loaded with what is captured and returned, followed by the caveat. No filler and every clause earns its place.

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

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

With no output schema, the description usefully covers return values and adds a meaningful limitation. However, for a 6-parameter tool with 0% schema coverage, the complete absence of parameter semantics leaves an agent guessing about layer, dimensions, and UI/HUD toggles.

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

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

Schema description coverage is 0% across 6 parameters (label, layer, width, height, show_ui, show_hud), and the description says nothing about any of them. With low coverage the description must compensate, and it provides zero parameter meaning.

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

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

States a specific verb (capture) and resource (Firestorm's rendered image) and even names the outputs (MCP image, saved PNG, hash). It does not differentiate itself from the related sibling capture_orbit, which likely also produces rendered captures, so it falls short of a 5.

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

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

There is no explicit when-to-use guidance and no routing to alternatives such as capture_orbit or image_compare. The closing caveat about render evidence not proving upload/visibility is an interpretive warning, not usage direction, so guidance remains largely 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 declare readOnly=false, destructive=true, and openWorld=true. The description adds genuine context beyond that: the two invocation paths (registered floater button callback vs coordinate-based click) and the fact that observe_path yields before/after state for verification. It stops short of stating reversibility or permission requirements, but adds real behavioral value.

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

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

Four compact sentences with the core action front-loaded and no filler. Each sentence carries information about invocation or verification, though the final 'verify from readback' sentence is slightly vague.

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

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

For a destructive, open-world mutation with no output schema and 0% schema coverage, the description covers the mechanism and verification path but omits prerequisites, error/failure behavior, and whether it waits for the click to settle. Adequate but with clear gaps for a tool of this risk profile.

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. It explains the roles of 'floater' (registered button callback) and 'observe_path' (before/after state capture), covering two of four parameters, but 'path' and 'button' remain entirely undocumented in both schema and description.

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 ('Click') and resource ('a visible, enabled control'), qualifying the target state clearly. However, it never distinguishes itself from close siblings like ui_select, ui_press_key, or ui_invoke_menu, so the agent must infer which UI action applies.

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 explains the internal mechanism (floater callback vs coordinates) but gives no when-to-use guidance or alternatives. It never says when to use ui_click rather than ui_select, ui_press_key, or ui_invoke_menu, leaving selection 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?

With annotations already covering the read-only/non-destructive/open-world safety profile, the description adds genuine behavioral context beyond them: case-insensitive matching, the max_depth=1 root+children rule, and the pagination caveat that 'each page still enumerates the requested subtree' (a notable cost implication). It omits return shape, but no output schema exists.

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

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

Three tightly packed sentences, front-loaded with the core purpose followed by depth semantics and pagination. Dense but no filler; each clause carries information.

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

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

For an 8-parameter tool with 0% schema coverage and no output schema, the description leaves most parameters (match modes, search_in, limit, include_info) undocumented in either place, so an agent cannot fully exploit the tool. Annotations cover safety but not the breadth of behavior needed here.

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

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

Schema description coverage is 0% across 8 parameters, so the description must carry parameter meaning. It explains query, under, and max_depth, but ignores match (contains/exact/prefix/glob), search_in (path/name), limit, and include_info entirely. It also says 'next_offset' while the actual parameter is 'offset', which risks confusion.

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: 'Search paths or basenames, case-insensitively, within a narrow under path.' An agent can tell this is a scoped, case-insensitive path/name search. It does not differentiate from siblings like inventory_search or floater_list, and the ambiguous 'paths' framing (UI vs filesystem) is left unclarified.

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 operational usage hints ('max_depth=1 includes root and children', 'Follow next_offset for more results') but never states when to use this tool versus an alternative such as inventory_search. Usage is implied through mechanics rather than explicit 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?

Annotations already declare readOnlyHint true, openWorldHint true, and destructiveHint false, covering the safety profile. The description adds a privacy-focused targeting caution that is not in annotations, but omits prerequisites, error behavior, and return format.

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: purpose first, then a targeted-usage rule. Every sentence contributes to selection or safe invocation.

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 single-parameter read tool with annotations covering safety, the description is largely complete: it says what is read and how to scope the path. It could still note that the path comes from ui_find or describe the returned value type, but the core is covered.

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 clarifies that 'path' identifies a specific discovered UI control and should be targeted, adding useful semantic context beyond a bare string, though it does not specify path syntax or source.

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, 'value of a specific discovered UI control,' so the core action is clear. However, it does not name or distinguish itself from siblings such as ui_inspect or ui_find, leaving sibling differentiation 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?

Offers a practical targeting rule, 'Use targeted paths to avoid unrelated chat or private fields,' which implies safe usage. But it never states when to choose ui_get_value over alternatives like ui_inspect or ui_set_text, and there are no explicit when-not conditions.

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, non-destructive, and openWorld. The description adds a meaningful behavioral trait beyond them: the operation does not open or focus the target, so it is inspection-only with no focus side effects. No auth, rate limit, or return-format detail is given, but the annotations carry the safety profile.

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

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

Two tight sentences, front-loading the read scope and then the alternative routing. Every clause earns its place with no redundancy.

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

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

For a single-param read tool with no output schema, the description covers what is read and the non-intrusive behavior. The main gap is that it does not describe what 'geometry' entails or the shape of the returned state, which would help an agent interpret results.

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 there is a single parameter 'path' with a default of /main_view. The description implies 'path' refers to a known UI path but does not specify format, syntax, or how paths are obtained, so it only partially compensates for the undocumented schema.

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

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

States a specific verb+resource combination: it reads a known UI path's geometry and enabled/visible state, and adds a distinguishing constraint ('without opening or focusing it') that separates it from ui_click/ui_select. It also names sibling ui_find for child discovery, so an agent can tell it apart from neighboring ui_* tools.

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

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

Clearly conveys the usage context ('known UI path') and routes to the alternative when you need to discover children ('with scoped ui_find'). It lacks an explicit when-not statement, but the 'known' qualifier effectively excludes exploratory discovery without calling this 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 destructiveHint=true and openWorldHint=true, so the safety profile is covered. The description adds real behavioral context beyond them: undispatched unknown callbacks (validation semantics) and the possibility of a native file picker opening as a side effect.

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 clauses, front-loaded with the core action, and no padding. Every phrase carries information (scope, validation behavior, side effect).

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 one-parameter destructive action with no output schema, the description covers the main risk (destructive native dialog) and validation failure mode. It falls short only on guiding the agent to discover valid names before invoking.

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

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

Schema coverage is 0% for the single 'name' parameter, so the description must compensate. 'By exact name' clarifies that the value must be a verbatim registered menu identifier, which is useful, but it omits where that name comes from and whether it is case-sensitive.

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 (invoke) and resource (menu entry from installed XUI) with a scoping qualifier ('exact name'). It is reasonably distinguishable from siblings like ui_click and ui_list_menus, though it doesn't explicitly name which sibling handles the discovery or low-level-click cases.

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

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

Implies usage via 'installed XUI by exact name' and the failure note about unknown callbacks, but never states when to prefer this over ui_click, ui_press_key, or ui_list_menus, nor that the name should first be discovered via ui_list_menus.

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/openWorldHint=false/destructiveHint=false, so safety is covered. The description adds genuinely new behavior context: results are scoped to this installation's XUI, and returned entries are descriptive rather than guaranteed-live actions, which is a real caveat an agent must not assume away.

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 the core action front-loaded and the interpretation caveat placed second. No filler; the only mild deduction is that the second sentence is slightly telegraphic.

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 read-only, single-optional-param listing tool with annotations covering safety and no output schema, the description supplies enough to call it correctly and to interpret results. Missing return-shape detail is excused by the absence of an 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?

Schema coverage is 0% and the single 'query' parameter is undocumented, but the description compensates partially by stating the filter matches name/label/function. It omits matching semantics (substring vs exact, case sensitivity) and the meaning of the empty default.

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 (viewer menu entries) scoped to 'this installation's XUI', which cleanly separates it from mutation-oriented siblings like ui_invoke_menu and ui_click. It does not explicitly name an alternative, but the action/resource pair is unambiguous.

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

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

Usage is only implied: a menu listing is naturally a discovery/read step, and the caveat about entries not being 'guaranteed enabled actions' hints at interpretation. There is no explicit when-to-use, when-not-to-use, or pointer to ui_find/ui_inspect as alternatives.

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

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

Annotations already flag destructive/openWorld/readOnly=false, and the description meaningfully adds preconditions (target path must be visible and enabled), the press/release behavior, side effects ('Enter can commit forms'), and a caveat that human input and shortcuts can interfere. This is substantial added context beyond the annotations, though the return/state read-back is only mentioned, not 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?

Three short, front-loaded sentences with no obvious filler; the action, modifiers, and caveats are ordered sensibly. Slightly telegraphic phrasing ('required visible, enabled path') costs a bit of 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?

For a destructive, open-world input tool with no output schema, the description covers preconditions and side effects reasonably but under-documents keysym and observe_path and does not describe what 'read back state' returns. Adequate but with clear gaps that an agent would notice before invoking.

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 only partly does: it lists the modifier values (matching the enum) and explains that path must be visible/enabled, but says nothing about the keysym format/syntax or the observe_path parameter at all. Two of four parameters remain undocumented.

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

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

States a specific verb and resource: focus a path, press/release a key, and read back state. This cleanly separates it from siblings like ui_click and ui_set_text, though the terseness of 'Focus a required visible, enabled path' leaves the path concept slightly under-explained.

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 explicit when-to-use or when-to-prefer-alternatives guidance relative to ui_click, ui_set_text, or ui_select. The note that 'Enter can commit forms' and 'verify the result' are behavioral hints, not routing guidance, so an agent gets no help choosing among the sibling UI input 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?

Annotations declare destructiveHint=true, openWorldHint=true and readOnlyHint=false, so the agent is warned this is a mutating, side-effect-capable operation. The description adds the precondition that the item must be visible and enabled and mentions a selected-value readback step, but says nothing about what side effects the selection may trigger or what happens on failure.

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

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

Two tightly packed sentences with the core action and precondition front-loaded and the fallback follow-up second. No filler text.

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

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

With no output schema, no annotation detail on returns, and 0% schema coverage, the description supplies the precondition, the value semantics, and the legacy fallback, which is close to sufficient. It stops short of covering failure modes or the readback comparison result the caller should expect.

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 both required parameters, so the description must carry meaning. It clarifies that 'value' is the actual value (not display label) and that the target is path-based, which is genuinely useful, but it does not explain path syntax or accepted value types for the anyOf value parameter.

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 (Select) and a specific resource (a visible enabled combobox item, identified by actual value), and the selector semantics are precise enough to distinguish it from generic ui_click. It even names the sibling it is not (path-targeted ui_press_key) for older viewers.

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

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

Gives a real usage condition ('when supported by the viewer') plus an explicit fallback path for older viewers ('ui_press_key with readback'), which is stronger than most siblings. It does not, however, say when to prefer this over ui_set_text or ui_get_value for the same control.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful behavior beyond that: it reads the value back (immediate feedback) and explicitly does NOT press Enter, telling the agent that form submission will not occur.

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 padding, with the core action and the read-back consequence front-loaded before the trailing constraint clause.

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

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

The annotations cover the mutation safety profile and the description covers the 'no Enter' side effect and read-back result, partially compensating for the missing output schema. Still absent: where a valid path comes from, whether focus/selection is required, and what happens on failure.

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 description supplies no meaning for either parameter. It implies 'text' is the replacement value and hints 'path' identifies a discovered control, but neither the path format nor whether the whole value is overwritten vs. appended is clarified.

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: 'Replace text in a discovered edit control', and adds that it reads the value back. An agent can distinguish it from read-side siblings like ui_get_value, though no sibling is named explicitly.

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

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

There is no statement of when to use this versus ui_get_value, ui_click, or ui_press_key, and no prerequisite that the control first be located (e.g. via ui_find). The only directional hint is the negative 'Does not press Enter', which is a boundary note rather than usable 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?

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds that the returned data is "live" and that it serves a discovery/reflection role, but does not say what the response contains or how stale or expensive the lookup is. With annotations carrying safety, a 3 is appropriate.

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

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

Two tight sentences, zero filler, with the core action front-loaded and the discovery guidance immediately after. 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?

For a read-only reflection tool with no output schema and 0% parameter coverage, the description covers the intent but leaves meaningful gaps: what the api/operation identifiers look like, and what the returned description/required-argument payload contains. Adequate but not complete.

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

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

Schema coverage is 0%, so the description must carry the load. It does map the two fields conceptually (api and operation) by saying it reads descriptions for "an API or operation", giving a hint that operation is a sub-selector, but it never says what form the api identifier takes or how the optional operation narrows the lookup.

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 the live description and required arguments for an API or operation. This clearly separates it from siblings like ui_inspect, asset_inspect, and viewer_call, though it never names 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?

"Discover before calling unfamiliar operations" gives a clear trigger condition and implicitly positions it as the prerequisite to viewer_call. It lacks an explicit when-not-to-use statement (e.g., for already-known operations), but the context is easy to infer.

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 openWorldHint=true, so the safety profile is covered. The description still adds real value: the LLSD typed-value encoding for arguments, the instruction to re-read state after writes, and the explicit warning that timeouts must not be blindly retried (a retry/idempotency hazard). These go 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?

Two tight sentences, front-loaded with the core action and then the two operational caveats. No filler, and the most important constraint (typed values in arguments) comes 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 destructive, open-world, no-output-schema tool with 5 undocumented parameters, the description is thin. It never explains what 'expect_reply' or 'timeout' do, how 'api' and 'operation' are discovered/named, or what failures look like, leaving critical invocation details 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 description coverage is 0% with 5 parameters, so the description must compensate and largely does not. It only illuminates the 'arguments' object via the {$uuid}/{$uri}/{$binary_base64} typed-value convention; 'api', 'operation', 'timeout', and 'expect_reply' remain entirely undocumented anywhere.

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 clear verb+resource: invoking a discovered viewer API operation. It is distinguishable from viewer_api_inspect (discovery) but the description never explicitly names that sibling or the discovery workflow, so sibling differentiation is left to 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?

The description gives post-call advice ('Read state after writes', don't blindly retry timeouts) but no guidance on when to choose this tool over alternatives such as viewer_api_inspect or the many typed sibling tools (ui_click, setting_set, etc.). Usage context is only implied.

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

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

Annotations already establish readOnlyHint=true, destructiveHint=false and openWorldHint=true, so safety is covered. The description adds genuine behavioral context beyond that: results are viewer-reported and completeness depends on simulator interest and viewer loading, warning the agent that output may be partial.

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

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

Two short sentences, front-loaded with the core action and followed by the availability caveat. No filler, though the second sentence is somewhat vague about the practical consequence of the 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?

For a small read-only tool with no output schema, the description should say more about what an object entry contains and how 'distance' shapes the result. The availability caveat is useful, but the return shape and parameter behavior remain unexplained.

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

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

There is one parameter, 'distance' (default 32), with 0% schema description coverage, yet the description never mentions it, gives no units, and does not explain whether it is a radius or a cutoff. With an undocumented parameter present, the description 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 and resource ('List nearby objects') and clarifies the data source ('as reported by the viewer'), which distinguishes it from sibling listing/inspection tools like asset_inspect or ui_list_menus. No explicit sibling differentiation is offered, but the scope is unambiguous.

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

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

Usage is implied by the verb 'List' and the 'nearby objects' scope, but the description never says when to prefer this over alternatives such as asset_inspect or mesh_preview_camera, nor does it state prerequisites or exclusions.

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