cesium-mcp

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

Annotations cover the safety profile (not read-only, not idempotent, not destructive), and the description adds the return shape and a practical pointer to use the returned id with highlight. No contradictions; it confirms the additive nature of the operation.

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 purpose and a compact return signature/tip. No filler or redundant details.

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 moderately complex tool with nested schema, the description covers the core behavior, supported geometries, return format, and a highlight integration tip. It relies on the schema for parameter details, which is acceptable given 100% schema coverage.

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

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

The schema already documents all six parameters with descriptions, so the description does not need to elaborate. It mentions 'styled' which maps to the style parameter, but doesn't add new semantic value beyond what the schema provides.

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

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

The description uses a specific verb ('Add') and resource ('styled GeoJSON Point, LineString, or Polygon layer'), clearly distinguishing it from sibling tools like addMarker or addGeoJsonPrimitive. It also notes the return id for highlight, reinforcing its function.

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 does not explicitly state when to use this tool over alternatives like addGeoJsonPrimitive. It provides a post-use hint ('use id with highlight') but no selection criteria or exclusions, leaving the choice 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 the operation is not read-only, not idempotent, and not destructive. The description adds the return shape and the large-dataset performance context, but does not disclose broader behavioral traits such as whether an existing layer with the same ID is replaced or whether rendering is asynchronous. With annotations available, this is adequate but not rich.

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

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

The description is two short sentences that front-load the core purpose and include the return contract. There is no filler or redundant elaboration.

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

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

Given the rich parameter schema, annotations, and output schema, the description is nearly complete for guiding invocation. It could offer more detail on trade-offs versus addGeoJsonLayer or side effects, but the structured fields already cover most operational details.

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

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

Schema description coverage is 100%, so each parameter is already well-documented in the schema. The description adds no additional parameter-level meaning beyond the general GeoJSON rendering context, which fits the baseline for high schema coverage.

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 clearly identifies the action ('Render GeoJSON as Cesium primitives') and the intended use case ('large browser datasets'). It distinguishes itself from the sibling tool addGeoJsonLayer by emphasizing primitives and large-scale performance.

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

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

The phrase 'for large browser datasets' provides clear context for when this tool is appropriate, implying a performance-oriented alternative to entity-based GeoJSON layers. It does not explicitly list exclusions or alternatives, but the usage context is strong enough to guide selection.

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 indicate readOnlyHint=false, destructiveHint=false, idempotentHint=false, but the description doesn't add behavioral context beyond the return format. It doesn't state whether labels are persisted, whether existing labels are overwritten, or if there are side effects. The description is neutral and doesn't contradict annotations.

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

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

The description is a single sentence that efficiently states the action and return format. It's front-loaded with the verb 'Add' and the resource 'property-based text labels for GeoJSON features'. 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?

The tool has a complex input schema (nested GeoJSON with geometry types) and an output schema, but the description doesn't explain edge cases, error conditions, or how labels interact with existing features. The output schema covers return values, so that's not needed, but behavioral details are missing.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds minimal value beyond the schema, only mentioning the return format. The 'field' parameter is well-described in the schema, and 'style' has a description. Baseline 3 is appropriate.

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

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

The description clearly states the tool adds property-based text labels to GeoJSON features and specifies the return format. It distinguishes from siblings like addGeoJsonLayer (which adds layers) and addMarker (which adds point markers), though it doesn't explicitly name alternatives.

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

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

The description implies usage for labeling GeoJSON features but doesn't explicitly state when to use this vs. alternatives like addGeoJsonLayer or addMarker. It doesn't mention prerequisites (e.g., layer must exist) or when not to use it.

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 indicate a non-read-only, non-destructive operation, so the bar is lower. The description adds valuable behavioral context beyond annotations: it discloses the return shape ({ success, data: { entityId }, message? }) and instructs to keep entityId for removeEntity, which helps the agent understand lifecycle management. No contradictions with annotations.

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

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

The description is two sentences, front-loaded with the core purpose, and includes essential return information without any fluff. Every sentence earns its place, making it highly efficient for an AI agent to parse.

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

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

Given the tool's simplicity and the presence of a full input schema and output schema, the description is adequate. It covers the primary action, return value, and a key follow-up (removeEntity). It could optionally mention that this is for map layers, but that is reasonably inferable from the sibling tool names and parameters.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description does not add significant parameter-specific meaning beyond what the schema provides. It reinforces that coordinates are geographic but does not provide additional semantics, so baseline 3 is appropriate.

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

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

The description clearly states the action ('Add a point marker') and the resource ('at geographic coordinates'). It distinguishes from sibling tools like addPolygon or addPolyline by explicitly specifying 'point marker.' The return format is also mentioned, leaving no ambiguity about what the tool does.

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 provides clear context for when to use the tool: adding point markers at coordinates. It does not explicitly mention alternatives or exclusions, but the specificity of 'point marker' implicitly differentiates it from adding other entity types. No misleading guidance is present.

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 are all false (readOnlyHint, openWorldHint, etc.) and provide no safety profile, so the description carries the full burden. It discloses the return structure ('Returns { success: boolean, ... }'), but since an output schema exists, this may be redundant. There is no mention of side effects (e.g., whether the model replaces an existing one), unit conventions beyond what's in the schema, or rate limiting. No contradictions, but little added behavioral insight.

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

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

The description is a single sentence with a clear verb and object, followed by a terse return-type note. Every word earns its place, and the information is front-loaded with the action. No fluff 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?

For a tool with 10 parameters, the description is minimal but acceptable given the full parameter documentation in the schema and the existence of an output schema. However, it lacks higher-level context such as what 'add' implies (e.g., does it create a new entity each time or replace one?), and it does not hint at parameter interactions (e.g., heading/pitch/roll relationships). It is adequate for simple use cases but not rich enough for complex scenarios.

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

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

Schema description coverage is 100%, with each parameter having a description (e.g., 'Heading angle (degrees), 0=North'). The description adds no additional parameter context, so it does not need to compensate. Per the rubric, a baseline of 3 applies when schema coverage is >80%.

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

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

The description uses a specific verb ('Add') and a specific resource ('glTF or GLB model') along with the spatial context ('at geographic coordinates'). This clearly distinguishes it from siblings like addMarker or addPolygon, which serve different entity types. The phrase 'glTF or GLB' unambiguously conveys the 3D model use case.

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 through the terms 'glTF or GLB model' and 'geographic coordinates', suggesting this tool is for placing 3D models in a 3D scene. However, there is no explicit mention of when to choose this over alternatives like addGeoJsonLayer or addLabel, nor any exclusions or prerequisites (e.g., needing a specific tile format). The guidance is implicit rather than explicit.

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

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

The description explicitly states the return shape { success, data: { entityId }, message? } and instructs the agent to keep entityId for removeEntity, adding valuable lifecycle behavior beyond the annotations. Annotations are all false and don't contradict the description, though it omits side effects like render persistence or permission requirements.

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 concise, front-loaded sentence plus a compact return note. Every word earns its place, with no filler or repetition of schema details.

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, the description is short but compensates with a fully documented schema, explicit output contract, and entity lifecycle hint. The main missing contextual element is usage comparison, but the essential invocation details are 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 100% and each parameter already has detailed descriptions including defaults and ranges. The description only adds the context of 'geographic coordinate tuples', which is marginal, so the schema carries the semantic burden and baseline 3 applies.

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

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

Description uses a specific verb 'Draw' and resource 'polygon area' from geographic coordinate tuples, clearly distinct from sibling tools like addPolyline or addMarker. The action is unambiguous and directly tied to the tool 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?

No guidance is provided on when to use addPolygon versus alternatives like addGeoJsonLayer or addPolyline. It lacks preconditions, exclusions, or context about preferred use cases, so the agent receives no decision support.

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 only provide readOnlyHint=false and destructiveHint=false, which are minimal. The description adds value by specifying the return schema ({ success, data: { entityId }, message? }) and instructs to keep entityId for removeEntity, disclosing that the tool creates a persistent entity that can later be removed. It does not mention side effects like persistence across sessions or overlay behavior, but it goes beyond the annotations.

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

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

The description is only two sentences and front-loaded with the primary purpose. It avoids redundancy, condenses the return format and a key usage hint into the second sentence, and contains zero filler 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?

With six parameters (one required), a rich input schema, and an output schema implicitly defined in the description, the tool is fully specified. The description explains the return value and points to removal, covering the necessary context for an agent to use the tool correctly without requiring additional details about return values or behavior.

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

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

Schema description coverage is 100%, with each parameter (coordinates, color, width, label, sessionId, clampToGround) having its own detailed description. The tool description adds minimal parameter information beyond what the schema already provides, so it meets the baseline of 3 without compensating for any gaps.

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

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

The description states the tool draws a path or route from geographic coordinate tuples, using a specific verb ('draw') and resource ('path or route'), and it distinctly differs from siblings like addPolygon, addMarker, and addLabel. It also clarifies the return structure and entityId purpose.

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 does not explicitly state when to use this tool versus alternatives like addPolygon or addGeoJsonPrimitive. The mention of 'path or route' implies use for line-based geometry, but no exclusions or alternative guidance is given. The return note about keeping entityId for removeEntity is a usage hint but not a direct guideline.

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 all annotation hints set to false, the description carries the full burden of behavioral disclosure. It only provides a return type and fails to mention crucial behaviors like whether the operation is atomic (all-or-nothing), how partial failures are handled, or what 'page operation' implies about side effects. This is insufficient for a batch mutation tool.

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

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

The description is exceptionally concise: one sentence plus return type. It front-loads the core action and avoids any fluff. Every word earns its place, making it easy to parse quickly.

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

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

Given the tool's complexity (batch operations across 11 entity types, a session ID for multi-browser routing, and sibling single-entity functions), the description is underpowered. It does not explain error handling, atomicity, or clarify when to use batch vs. individual adds. The output schema covers return values, but usage context is severely lacking.

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

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

The schema covers 100% of parameters with descriptions, so the baseline is 3. The description adds minimal semantics beyond what the schema already provides, except for the phrase 'one page operation,' which suggests batch atomicity but is ambiguous. It does not deepen understanding of the parameters themselves.

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 clearly states the action 'Add multiple supported entities in one page operation', which is specific enough to understand the tool's purpose and differentiates it from single-entity sibling tools like addMarker or addLabel by using 'batch' and 'multiple'. However, 'supported entities' is vague without the schema, and an explicit comparison to the add* functions would have been stronger.

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

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

There is no guidance on when to use this tool versus the individual add* functions. The phrase 'one page operation' hints at a key use case (e.g., atomic batch adds), but this is never explicitly stated. No alternatives or exclusions are mentioned, leaving the agent to guess when this is the right choice.

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 idempotentHint=true. The description adds specificity by listing exactly what is cleared (layers, entities, animations, trajectories) and the return payload with removed counts. This supplements the annotations without contradicting them.

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 sentence conveying the action and return value. No filler, front-loaded with the core purpose, and the return structure is compactly noted.

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

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

The tool is simple (no required params), annotations cover safety (destructive, idempotent), and the description specifies the scope and return format. The only minor gap is not mentioning any side effects like session-scoped clearing, but overall it is sufficiently complete for a tool of this complexity.

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

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

The only parameter, sessionId, is fully described in the schema (optional, for multi-browser routing). The description does not mention parameters at all, but given 100% schema coverage, the baseline of 3 is appropriate—no additional semantic burden on 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 clearly states the tool clears all layers, entities, animations, and trajectories from the scene. The verb 'clear' and resource scope are explicit, and the return structure distinguishes it from more granular sibling tools like removeLayer and removeEntity.

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 makes the use case obvious—bulk clearing of the scene—but does not explicitly mention when not to use it or contrast with alternatives like removeLayer or removeEntity. The context is clear, but no exclusions or alternative guidance is provided.

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 idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful context by instructing to list toolsets first, which helps set expectations for use.

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

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

The description is two concise sentences, front-loaded with the purpose and followed by a clear, brief usage hint. 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 simple one-parameter tool with idempotency and non-destructive annotations, the description fully explains what the tool does and the necessary preliminary step. No output schema is present, so return values need not be 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?

The input schema provides a 100% description coverage for the single parameter 'toolset', including examples. The description does not add further parameter details beyond what the schema already supplies, meeting the baseline.

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

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

The description uses a specific verb 'Enable' and clearly identifies the resource 'a tool group'. It distinguishes from sibling tools like list_toolsets by stating that this action activates a group rather than listing 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?

The description provides explicit guidance to call list_toolsets first, establishing a clear prerequisite. It does not mention when not to use, but for a simple tool this is adequate context.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the return contract ({ success, data?, message?, error? }) which is helpful, but it does not explain what 'current' means across sessions or whether this includes transient UI state, though the output schema may cover return specifics.

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 efficient sentences: the first states the action and target, the second provides the return shape. Every word earns its place—no filler or repetition of the tool name.

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, zero-required-parameter tool with an output schema and clear annotations, the description is largely sufficient. Minor gap: it doesn't clarify whether 'current' view/layer/entity state includes all sessions or just the one tied to sessionId, but given the simplicity and existing structured data, this is acceptable.

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 description does not discuss parameters, but the input schema covers 100% of the single optional sessionId parameter with its own description. The baseline of 3 applies because the schema handles semantics; no extra value is added by the tool 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 uses the specific verb 'Export' and names the exact resources: 'current view, layer, and entity state' as JSON. It clearly differentiates from siblings like getView (which likely just returns view) or queryEntities (which queries specific entities) by indicating a full export of scene state.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives like getView or queryEntities. The usage context (e.g., 'use when you need the complete scene snapshot') is only implied by the word 'Export' and is not spelled out for the agent.

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

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

Annotations already declare non-destructive, idempotent, and non-read-only hints, so the bar is lower. The description adds that it animates (implying state change) and returns a structured object with success/error, but doesn't provide further behavioral detail like whether it interrupts previous animations or affects other entities. It meets minimum adequacy but adds limited 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?

The description is three concise sentences: purpose, usage, and return type. It is front-loaded with the core action, uses no filler, and every sentence adds value. It's an exemplar of minimal yet informative documentation.

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?

Despite having 7 parameters, the tool is straightforward—animate camera to a location with optional adjustments. The description covers the action, when to use, and return shape. The schema fully documents parameters, and no output schema is needed since the description states the return object. For a simple camera animation, this is 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 100% with each parameter having a description. The description doesn't add any parameter-specific information beyond what's in the schema, but it does mention the return object structure (success/message/error). With full schema coverage, a baseline of 3 is appropriate; the description neither adds nor detracts from parameter understanding.

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 clearly states the tool animates the camera to a geographic location, distinguishing it from sibling tools like setView (likely non-animated) and zoomToExtent (based on extent). It specifies the verb 'animate' and the resource 'camera' with geographic targeting, making the purpose unambiguous.

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

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

The description provides clear guidance: 'Use for visible navigation requested by the user.' This implies it's for explicit user-requested camera movement, differentiating from programmatic or default navigation. However, it doesn't name specific alternatives or exclusionary cases, though the sibling list indicates similar tools exist.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so safety profile is covered. The description adds the return type shape ({ success, data?, message?, error? }), which is useful, but it does not disclose error behavior, missing-entity handling, or any additional side effects beyond the annotations.

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

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

The description is a single sentence plus a compact return-type signature. It front-loads the core purpose and wastes no words.

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

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

For a simple read-only tool with rich annotations and an output schema, the description covers purpose and return shape sufficiently. Minor gap: no mention of what 'graphics metadata' includes or how errors are surfaced, but this is acceptable given the output schema and context.

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

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

Schema description coverage is 100% with meaningful parameter descriptions (e.g., entityId obtainable via queryEntities, sessionId for routing). The description itself adds no parameter details, but the schema fully documents them, so baseline 3 is appropriate.

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

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

The description uses a specific verb ('Read') and resource ('properties and graphics metadata for one entity'), clearly distinguishing it from siblings like queryEntities. It precisely identifies the tool's scope as a single-entity read operation.

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 alternative guidance appears in the description. It implies use for reading properties of one entity but does not contrast with queryEntities or explain when this tool is preferred over other list/query 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 already declare readOnlyHint, idempotentHint, and destructiveHint, covering safety. The description adds value by specifying what is inspected (fields, counts, metadata) and the return structure, but it does not disclose edge cases or side effects beyond that. It complements annotations without contradicting them.

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

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

The description is a single concise sentence plus a return type line, front-loaded with the primary action. Every word adds meaning, with no fluff or repetition of component names. It is well-structured for quick scanning by an agent.

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 read-only tool with two parameters and a generic output schema, the description covers the essential purpose and return format. The output schema exists, so detailed field explanation is not needed. It misses potential error cases or notes on layer existence, but annotations and parameter docs cover safety and IDs sufficiently. Only a minor gap remains regarding what happens when a layer is invalid.

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

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

The schema provides 100% coverage with descriptions for both parameters. The layerId description ('Layer ID (get via listLayers)') adds useful context for obtaining the ID, and sessionId explains its routing purpose. The tool description itself adds no further parameter semantics, so it meets the baseline for full coverage.

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 clearly states the action ('Inspect') and the resource ('fields, entity counts, and metadata for a layer'). It is specific enough to distinguish it from generic listing tools like listLayers or entity queries, though it does not explicitly name alternatives.

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

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

The description indirectly implies usage (when you need layer schema details) but provides no explicit guidance on when not to use it or which sibling tools are better alternatives. The readOnlyHint and sibling names give context, but the description itself lacks direct usage direction.

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

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

Annotations already declare read-only and idempotent behavior. The description adds the return structure (success, data fields, message), which provides useful context beyond the annotations.

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

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

The description is two concise sentences, including the return format. It is appropriately sized with no redundant 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?

Given the simplicity of the tool and that the schema covers the parameter, the description sufficiently covers purpose and return. The sibling tools provide context, and there is no output schema, but the textual return description 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?

The only parameter, sessionId, is already fully described in the schema with its purpose and optionality. The description adds no additional meaning, so the baseline score of 3 applies due to high schema coverage.

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 clearly states the tool's function: retrieving the current camera position and orientation. It distinguishes from sibling tools like setView and flyTo, which modify the camera, by using 'get' and 'current'.

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

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

The description implies usage for reading camera state but does not explicitly state when to use it over alternatives or mention any prerequisites. Given the getter nature, it is clear, but no explicit when-not guidance is provided.

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 tool as non-destructive, non-read-only, and idempotent. The description adds the return type ({ success, error }) and implies highlight is applied, but does not disclose effects on layer state, persistence, or interaction with other styling. It adds some value beyond annotations but is not rich in behavioral detail.

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

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

The description is concise (two sentences) and front-loaded with the core action. It includes the return type without unnecessary detail. This meets the standard for clear, efficient tool descriptions.

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

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

Given the simple nature of the tool, complete schema coverage, and no output schema provided, the description adequately covers the main outcome and return shape. It could mention that highlights are undoable via the clear parameter or that styling is temporary, but these are implied by the schema. Overall, it is sufficiently complete for an agent to invoke it correctly.

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

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

The input schema already provides descriptions for all five parameters, including the behavior of featureIndex when omitted. The description adds minimal value by restating that one or all features can be highlighted, which mirrors the schema. No additional parameter semantics are provided.

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 clearly states the action: 'Highlight one feature or every feature in a GeoJSON layer.' It specifies the resource (GeoJSON layer) and the scope (one or all features), which distinguishes it from sibling tools like updateLayerStyle or setBasemap. The return type is also mentioned, adding to purpose clarity.

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 is given on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or scenarios where a different tool would be more appropriate. The description only states what the tool does, leaving the agent to infer usage context on its own.

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

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

The annotations clearly state readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which already set the safety profile. The description adds the return shape but not much behavioral context beyond that. It does not contradict annotations. Since annotations already cover the key behavior, the description adds minor context (return type) but not significant extra disclosure.

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

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

One sentence describing purpose, one sentence for return value. No fluff. Front-loaded with the action.

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 output schema present and annotations covering safety, the description is sufficient for a simple read-only list operation. It tells the agent what happens (lists layers) and the return format. It could specify that the layers are objects vs strings, but that's a minor gap. The tool is simple, so completeness 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?

Schema coverage is 100% with only one optional【来源：春色 inspiration cove words (cir(es); (2) (3) (4) (5) (6 (7) null (8 (9) null (10 null ) (11 null] (12_____ MCP uses schema descriptions. The description mentions the return type and that sessionId is used for multi-b} (20 null (21 null (22 null (23 null (26 null (27 null (" (28 null (31 null (

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 clearly states the purpose: 'List all layers currently managed by the page.' The verb 'List' is specific and distinguishes the tool from siblings like addGeoJsonLayer and removeLayer.

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 provides no guidance on when to use this tool versus alternatives. It does not mention that this is a read-only operation or when it should be preferred over queryEntities or getLayerSchema. The context of 'currently managed by the page' is some guidance but not explicit.

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

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

The description adds value beyond the annotations by specifying that only 'connected' sessions are listed and that each session includes an ID and connection state. This clarifies the scope (connected only) and the return fields, complementing the readOnlyHint and idempotentHint annotations.

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

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

The description is a single, focused sentence that front-loads the core information (what it lists) and explains its purpose. Every word contributes without 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 tool with no parameters and no output schema, the description supplies the key details: what is listed (sessions), the filter (connected), the data included (ID and state), and the purpose (multi-browser routing). This is sufficient for an agent to select and invoke the tool correctly.

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

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

The tool has zero parameters, and the schema confirms this with an empty properties object. The description correctly does not attempt to document nonexistent parameters, and no additional parameter semantics 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?

The description 'List all connected browser sessions (ID and connection state) for multi-browser routing' clearly identifies the action (list), the resource (browser sessions), and the output (ID and connection state). It distinguishes itself from sibling listing tools like listViewpoints or listLayers by specifying 'browser sessions'.

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

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

The phrase 'for multi-browser routing' provides clear context for when this tool is useful, implying it is used to identify available sessions for routing decisions. However, it does not explicitly mention alternatives or exclusions, so it falls short of the highest score.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, satisfying the safety profile. The description adds value by noting it returns enabled status and serves discovery of capabilities. It doesn't elaborate on response structure, but that's not critical for this simple read-only listing 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?

Two concise sentences. The first is a clear statement of purpose, the second provides usage context. No fluff or redundancy; 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 strong annotations, the description is complete. It states what is returned (tool groups and enabled status) and when to use it (before configuration). No output schema exists, but the description sufficiently conveys the outcome.

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

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

The tool has zero parameters, so schema coverage is trivially 100%. The description correctly implies no inputs are needed. Baseline score of 4 is appropriate given no parameter info 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?

The description explicitly states the action ('List all available tool groups'), the resource ('tool groups'), and the specific output content ('their enabled status'). It clearly distinguishes this from sibling tools like enable_toolset by focusing on listing/discovery rather than modification.

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

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

Provides explicit guidance: 'Call this to discover additional capabilities before asking the user to configure anything.' This tells the agent exactly when to invoke the tool and sets a clear prerequisite context (discovery before configuration).

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 disclose the key safety traits (readOnlyHint=true, destructiveHint=false, idempotentHint=true). The description adds the useful 'current page' scope but does not go beyond that to describe behaviors like empty result handling, ordering, or pagination. With annotations present, this is adequate but not rich.

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

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

The description is two sentences: one functional statement and one return signature. There is no fluff or redundancy; it is efficiently front-loaded with the core purpose.

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, idempotent tool with one optional parameter, rich annotations, and an output schema, the description is sufficient. It clarifies the scope ('current page') and the return envelope, and no further behavioral or safety details are necessary.

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

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

Schema description coverage is 100%: the only parameter sessionId is fully described in the input schema. The description adds no additional parameter semantics, but with full schema coverage the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'List camera viewpoints saved in the current page.' This clearly distinguishes the tool from siblings like saveViewpoint/loadViewpoint and getView/setView by scoping to saved viewpoints and the current page.

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 purpose implicitly suggests when to use the tool (to enumerate saved camera viewpoints), but there is no explicit when/when-not guidance or mention of alternatives. The 'current page' scoping provides some context but no direct comparison with related sibling 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 already indicate readOnlyHint=false and destructiveHint=false, showing it mutates state but not destructively, plus idempotentHint=true. The description adds the fact that it is 'page-local' and provides a return shape of a success flag and optional fields, exceeding annotation coverage slightly. It does not disclose aspect such as missing viewpoint handling; the return type hints at error reporting but doesn't elaborate.

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

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

The description is a single, front-loaded sentence stating the purpose and return type. It contains zero fluff or repetition, making it highly concise and clear.

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

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

Given that it's a simple restore operation with a well-documented schema and annotations, the description is sufficient. It covers the return format and the key action. It doesn't explain what happens if the viewpoint doesn't exist, but the output schema includes 'error' to cover that. Thus it is fairly complete for its scope.

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

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

Schema description coverage is 100%, so the schema fully documents all three parameters (name, duration, sessionId). The description adds no extra detail about parameters, so baseline of 3 is appropriate since it neither hurts nor helps beyond schema.

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

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

The description clearly states the verb 'Restore' and the resource 'previously saved page-local camera state', which precisely indicates the tool's function. It distinguishes itself from sibling tools like saveViewpoint, listViewpoints, and setView by emphasizing 'restore' of a saved state rather than creating, listing, or directly setting a 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?

It implies use when you want to revert to a saved camera state, and the phrase 'previously saved' notes a precondition. While it doesn't compare against alternatives like flyTo or setView, the 'restore' semantic clearly differentiates it from immediate camera manipulation. However, it lacks explicit notes on when not to use it.

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 discloses the return structure, which adds context beyond annotations. However, it does not mention potential side effects such as displaying on a map (showOnMap parameter) or session context. Annotations are all false, so the description carries the burden but only partially covers behavior.

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

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

The description is concise with a single sentence stating the purpose, followed by the return format. All sentences are informative 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 5-parameter tool with a rich schema and output schema, the description is mostly complete. It could benefit from clarifying units or the minimum positions for area, but overall it provides sufficient context.

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

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

Schema description coverage is 100%, so the schema fully documents the parameters. The description does not add additional parameter semantics beyond restating the purpose.

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 clearly states the tool measures distance or area between coordinate tuples, using a specific verb and resource. This distinguishes it from sibling tools with no ambiguity.

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

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

The description implies usage when measurement is needed, but does not explicitly provide when-to-use guidance or contrast with alternatives. The purpose is clear enough that no alternative tool is obvious, but explicit guidance is missing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds the return type shape and filter semantics, which goes beyond annotations without repetition.

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, 13 words before the return shape. Front-loaded with the verb and resource, 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?

For a read-only query tool with all-optional parameters, the description and output schema are sufficient. Minor ambiguity whether no filters returns all entities, but this is a common accepted behavior.

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 covers all 4 parameters with descriptions and 100% coverage. Description paraphrases three of them but does not add new meaning beyond what schema already provides. Baseline 3 is appropriate.

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

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

Clear verb 'Query' plus resource 'page entities' and three filter dimensions (name, type, geographic extent). Instantly distinguishable from sibling mutation tools like addMarker and removeEntity.

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 for retrieving entities by optional criteria. No explicit exclusions or comparisons to alternatives, but context from sibling names (add*, update*, remove*) makes it obvious this is the querying 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 readOnlyHint=false, so the destructive nature is covered. The description adds valuable behavioral context by specifying the return shape and error handling: 'Returns { success, message? } or { success: false, error } when entityId is not found.' This goes beyond schema and annotations, clarifying the expected outcome and failure case.

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

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

The description is only two sentences, front-loaded with the purpose and then the return behavior. No redundant information. Every sentence adds value, making it concise and well-structured.

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

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

The tool is simple (2 params, 1 required), annotations cover destructive and idempotent hints, and the description provides the return shape and error case. The output schema existence further reduces need for description. Given the tool's simplicity and rich structured data, the description is fully 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?

Schema description coverage is 100%, with both entityId and sessionId having descriptive comments. The tool description adds little beyond the schema; it mentions 'entity created by an entity tool' which clarifies the type of entityId, but this is marginal. Baseline 3 is appropriate given the high schema coverage.

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 clearly states the tool's function: 'Remove one entity created by an entity tool.' It uses a specific verb ('Remove') and resource ('entity'), and distinguishes from siblings like removeLayer and clearAll by specifying it targets entities from entity tools. The return format is also mentioned, adding to purpose clarity.

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 provides clear context on when to use it (to remove entities created by entity tools) but does not explicitly mention when not to use it or point to alternatives like updateEntity or removeLayer. It implies usage through the phrase 'entity created by an entity tool,' which differentiates from layer removal, but lacks explicit exclusions or alternative recommendations.

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

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

Annotations already indicate destructiveHint=true and idempotentHint=true. The description adds useful context that the removal is scoped to the page's managed layer representation, but it does not elaborate on permanence or side effects on underlying data. No contradiction with annotations.

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

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

The description is one short, front-loaded sentence followed by the return shape. Every word earns its place, and there is no redundancy or unnecessary detail.

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 remove operation with good annotations and full schema coverage, the description is nearly sufficient. It could clarify what a 'managed layer' is or how it relates to listLayers, but those gaps are minor given the output schema and annotations.

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

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

Schema coverage is 100%, and both parameters already have clear descriptions in the schema. The tool description itself adds no parameter-level semantics, so the high schema coverage carries the weight.

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

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

The description uses a specific verb ('Remove') with a specific resource ('managed layer') and scope ('from the page'), which clearly distinguishes it from sibling tools like removeEntity and clearAll.

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 usage guidance is provided beyond the verb itself. The description does not mention when to use this tool versus removeEntity, clearAll, setLayerVisibility, or other layer-related tools, and no exclusions or alternatives are named.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, but the description adds a return structure ({ success, data, message, error }) and clarifies the 'page-local' scope. This is useful beyond annotations and does not contradict any of them.

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

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

The description is a single, direct sentence followed by the return type. Every word earns its place with no redundancy or fluff.

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

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

The tool is simple, annotations cover safety, the output schema is described indirectly, and the description sheds light on page-local semantics. It is complete enough, though it lacks a mention of overwrite behavior (covered only in schema) and does not explicitly state that repeated saves with the same name are allowed.

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

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

Schema description coverage is 100%, and the schema already provides detailed descriptions for both parameters (including overwrite behavior for 'name' and multi-browser routing for 'sessionId'). The description adds no new meaning beyond the schema, so it meets the baseline.

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

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

The description clearly states 'Save the current camera state under a page-local name,' which specifies the verb ('save'), the resource ('current camera state'), and the scoping ('page-local'). It distinguishes from siblings like loadViewpoint and listViewpoints by focusing on writing a named state.

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

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

The description implies usage for saving a viewpoint for later retrieval, but it does not explicitly mention alternatives (e.g., loadViewpoint) or when not to use this tool. There is no exclusion or preference guidance, so it is only minimally adequate.

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, idempotentHint=true, and destructiveHint=false, which align. The description adds genuine value by disclosing the exact return shape { success, data: { dataUrl, width, height }, message? } and clarifying dataUrl is a base64 PNG. Missing details, like resolution behavior or error edge cases, keep it from a 5, but annotations lower the bar here.

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 wasted words. First sentence states the action; second provides the return structure. Every phrase earns its place, and the structure is front-loaded with the most critical information 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 zero-required-param, read-only tool with no output schema (compensated by an inline return-shape description), the description is nearly complete. It covers behavior and return format. A minor gap: no mention of capture dimensions/scale relative to the canvas, but this is not critical for an obvious screenshot tool, and the sibling-heavy context is handled well.

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

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

With only 1 optional parameter at 100% schema description coverage, the schema already documents sessionId's purpose ('Target browser session ID for multi-browser routing'). Description adds nothing about parameters, but does not need to; per rubric, high coverage sets a 3-4 baseline, and the simple schema is fully self-explanatory.

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 starts with a specific verb+resource+format combo: 'Capture the current Cesium map view as a PNG image.' It clearly distinguishes the tool's action (visual capture of the viewport) from siblings like exportScene or getView, making the sibling differentiation implicit but effective.

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 does not explicitly address when to use this tool over alternatives like exportScene, nor does it mention exclusions or prerequisites (e.g., map must be initialized). The action is clear enough that usage context is implied, but there is no explicit guidance or alternative tool naming, capping this at a mid-range score.

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 provide readOnlyHint=false, idempotentHint=true, destructiveHint=false, and the description does not contradict them. It adds the return structure, but beyond that, it does not disclose any additional behavioral traits such as prerequisites, side effects, or authentication needs.

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

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

The description is a single, tightly written sentence that states the core action and the return shape. There is zero redundancy or filler, making it highly concise and front-loaded.

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

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

While the schema and annotations cover much, the description is minimal. It does not mention when to prefer url vs basemap, how the switch interacts with existing layers, or any session-specific behavior. Given the tool's side-effect nature (changing visible basemap), more context would be beneficial, but it is still adequate given the rich schema.

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

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

Schema description coverage is 100%, and every parameter (url, token, basemap, sessionId) is fully described with types, constraints, and enums. The description adds no new semantics beyond what the schema already provides, so the baseline score of 3 applies.

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

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

The description clearly states the action ('Switch the visible basemap style') with a specific verb and resource. It is unique among siblings (no other tool deals with basemaps), so it distinguishes well.

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 does not provide explicit when-to-use guidance or mention alternatives. Since no sibling directly relates to basemaps, this is less critical, but it also omits context like custom URL vs presets or session-specific behavior.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the 'managed layer' scoping and the standard return envelope, but does not disclose additional behavioral details (e.g., persistence, error conditions). No contradiction with annotations.

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

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

The description is a single front-loaded sentence followed by the return shape. It is waste-free and appropriately sized for the tool's simplicity; no filler or repetition.

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

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

For a three-parameter tool with full schema coverage, annotations, and an output schema, the description is nearly sufficient. It clearly states the core action and returns. Minor gap: no mention that this affects only managed layers, but that is inherent in the phrase 'managed layer' and the tool's scope is otherwise 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 100%, with each parameter having a concise description ('Layer ID', 'Whether visible', 'Target browser session ID for multi-browser routing (optional)'). The description adds no extra meaning beyond the schema, so the baseline 3 applies.

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

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

The description uses a specific verb and resource: 'Show or hide a managed layer.' This clearly distinguishes it from layer-deletion tools like removeLayer and styling tools like updateLayerStyle. The action is unambiguous and directly tied to the tool's 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 implies usage through its purpose—use when you need to change a layer's visibility—but it does not explicitly state when to use it versus alternatives, and no sibling tools are referenced. For a simple tool, this is adequate but not exemplary.

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 idempotentHint=true and destructiveHint=false, so the safety profile is known. The description adds that the camera position changes immediately without animation and that the function returns a structured result. This adds some behavioral detail but does not go beyond what annotations imply (e.g., no discussion of failure modes or state effects). No contradiction with annotations.

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

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

The description is just two sentences, front-loaded with the core action and use case. Every word earns its place—no fluff, no repetition of schema or annotation information. Ideal conciseness for an agent consuming the description.

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

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

Given the 7 params (2 required), existing output schema, and annotations, the description is complete enough: it states the purpose, immediate execution, and return shape. It could mention edge cases like invalid coordinates, but the schema's validation ranges and the output's error string cover that. Slightly more detail on when to use versus flight animations would boost completeness, but it's already 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 input schema covers 100% of parameters with descriptions (e.g., roll, pitch, height, heading, etc.), so the description does not need to explain parameter meanings. The tool description adds no extra parameter context, but the baseline 3 is appropriate because the schema fully documents the parameters.

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

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

The description clearly states the tool's purpose: 'Set the camera position immediately without animation.' The verb 'set' and resource 'camera position' are specific, and the contrast with animated alternatives (like flyTo) is implicit. It distinguishes from sibling tools by emphasizing immediacy and determinism.

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 explicitly advises 'Use for deterministic setup or instant view changes,' providing clear guidance on when to invoke the tool. It does not name alternatives, but the phrase 'without animation' implicitly distinguishes it from flyTo, and the context with siblings makes the intended usage clear. Minor omission: no explicit 'do not use for animated transitions,' but the guidance is adequate.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=true, which cover safety and idempotency. The description adds the return format (success, data, message, error) but does not mention partial vs. full updates, behavior on non-existent entities, or error conditions, which would enhance transparency.

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

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

The description is a single sentence stating the action and return type, with no filler. It is front-loaded with the purpose and concise enough to be quickly parsed.

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?

While annotations and output schema cover many aspects, the description does not address prerequisites (e.g., entity must exist) or specific error scenarios. It is adequate for basic usage but lacks detail on failure modes and the effect of partial updates, 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?

Schema description coverage is 100%, and each parameter has a description. The tool description adds no additional meaning beyond the schema, so it meets the baseline but does not provide extra guidance on parameter relationships or usage nuances.

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 clearly states the tool updates an entity's position, appearance, label, or visibility. This is a specific verb (update) and resource (entity), and it distinguishes from sibling tools like addMarker or removeEntity by focusing on mutation of existing entities.

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

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

The description does not explicitly state when to use this tool versus alternatives like addMarker or removeEntity. It implies usage for modifying existing entities but lacks explicit guidance on distinctions or exclusions, leaving the agent to infer 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?

The description accurately reflects a mutation operation (readOnlyHint: false) but adds no extra behavioral context beyond what annotations already provide. The return type structure is mentioned, but since an output schema exists, this is redundant. No mention of authentication, rate limits, or side effects, though the annotations (idempotentHint: true, destructiveHint: false) already cover some safety aspects.

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

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

The description is one concise sentence that gets straight to the point, followed by a compact return type definition. Every word earns its place without fluff or repetition. The structure effectively front-loads the purpose before any ancillary details.

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

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

Given the tool's complexity (7 params, nested objects, multiple style types), the description is underspecified. It does not mention that exactly one of the style parameters (tileStyle, labelStyle, layerStyle, imageryStyle, primitiveStyle) should be provided at a time, nor does it clarify that these are mutually exclusive overrides. The return type is covered by the output schema, so that part is fine, but the core usage constraint is missing, which could lead an agent to mistakenly pass multiple style objects.

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 description does not discuss parameters directly, but the input schema covers 100% of parameters with rich descriptions for each style object (e.g., '3D Tiles style (Cesium3DTileStyle expressions: color, show, pointSize, meta)'). Since schema coverage is high and the descriptions are detailed, the main description has little obligation to add more. However, it misses an opportunity to highlight constraints like mutual exclusivity across style types.

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

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

The description clearly states 'Update vector, imagery, primitive, or 3D Tiles styling for a layer,' which is a specific verb+resource with explicit scope. It distinguishes this tool from siblings like setLayerVisibility (which handles show/hide) and addGeoJsonLayer (which adds layers). The mention of supported style types (vector, imagery, primitive, 3D Tiles) precisely defines the tool's domain.

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 provides no guidance on when to use this tool versus alternatives or when not to use it. While the parameter descriptions for imageryStyle and primitiveStyle mention 'use setLayerVisibility for show/hide,' this is buried in the schema and not part of the main description. The description fails to state prerequisites, such as the layer must already exist or that only one style key should be provided at a time.

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

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

The annotations already indicate idempotentHint true and destructiveHint false, so the description does not contradict these. However, the description adds little beyond stating the animation action; it does not mention potential side effects, permissions, or behavior on invalid input. Given annotations cover the main safety aspects, a baseline score of 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?

The description is a single, concise sentence that conveys the essential purpose without any fluff. It efficiently states the action and target, making it easy to understand at a glance.

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

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

Given that the schema fully documents parameters and annotations cover safety, the description is adequately complete for a tool of this simplicity. It clearly states the action and return type, though it omits usage guidance, which is a minor gap. Overall, the description is complete enough for an agent to understand the tool's function.

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

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

The schema provides detailed descriptions for all parameters (bbox, duration, sessionId) with types, ranges, and defaults. The description adds no extra clarity about parameters, and since schema coverage is 100%, a baseline score of 3 is justified.

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 clearly states the action ('Animate the camera') and the target ('a west/south/east/north bounding box'), making it obvious what the tool does. It distinguishes from sibling tools by specifying animation, which is a key differentiator from setView or flyTo that might be immediate.

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 does not provide any context on when to use this tool versus alternatives like flyTo or setView. It lacks guidance on conditions or scenarios where this tool is preferred, which is important given the presence of similar camera-control tools in the sibling list.

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