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

With no annotations, the description carries the full behavioral burden. It discloses that the tool returns parameters, types, and descriptions, but it does not say what happens when the name is not found, whether matching is exact or fuzzy, or whether class docs include inherited methods.

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 what is returned and followed by the usage condition. Every clause adds information without waste.

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

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

For a one-parameter read-only documentation lookup with no output schema, the description is mostly complete: it explains what content is returned and when to use the tool. The main missing piece is not-found or fallback 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 coverage is 100%, so the baseline is 3. The description nevertheless adds useful examples such as 'addGeocoderICGC' and 'Config.getConfigICGC', which illustrate class-qualified names beyond the schema's simpler 'addMarker' or 'Map.addMarker' example.

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

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

States a specific verb and resource: returns detailed documentation for a concrete mapicgc-gl-js method or class. The phrase 'quan ja saps (o intueixes) el nom exacte' implicitly distinguishes it from the sibling search_docs tool.

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

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

Explicitly says to use this tool when you already know or can guess the exact function name. It does not explicitly name search_docs as the alternative for unknown names, but the condition makes the intended routing clear.

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

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

No annotations are provided, so the description carries the full disclosure burden. It implies a read-only lookup, but says nothing about the return format (raw markdown text?), size, pagination, or whether a non-existent version errors or returns empty — gaps for a tool with zero annotation coverage.

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

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

A single well-formed sentence that front-loads the default behaviour and then the conditional narrowing. Nothing is wasted.

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

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

For a one-optional-parameter read tool with no output schema, the description plus schema give an agent everything needed to invoke it correctly. Only the return-shape ambiguity keeps it from being fully complete.

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

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

Schema coverage is 100% and the single parameter already documents the version example and the omit-for-full-history behaviour. The description largely repeats that same semantic rather than adding matching rules (exact string vs semver, case sensitivity), so it earns the baseline 3.

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

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

The description names a specific verb (retorna) and a specific resource (the CHANGELOG of mapicgc-gl-js), plus the narrowed scope of a single version. It is clearly distinct from the sibling tools (get_api, search_docs, get_example), though it does not explicitly state that differentiation.

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

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

It spells out both modes of use: omit the version to get the whole history, or pass a version like '1.0.0' to get only that release's entries. It gives no when-not guidance or alternatives, but the conditional branch is explicit and enough to pick the call shape.

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

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

No annotations, so the description carries the burden. It does add that examples are 'complet i funcional' and 'based on the real library API', which signals output quality, but says nothing about format/length of the returned snippet, whether it is read-only, or any limits.

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

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

Two tight sentences, front-loaded with the return value, followed by the topic enumeration. Nothing redundant or padded.

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

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

For a one-parameter, no-output-schema tool the description covers what it returns conceptually, but leaves the shape of the response (snippet only? multiple files? framework version?) unspecified, which matters for a code-generation tool.

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

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

Schema coverage is 100% and the single 'topic' parameter is already documented with examples in the schema. The description's topic list partially duplicates that, adding a few extra valid values but no new syntax or constraints.

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

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

States a specific verb and resource: returns a complete, working code example for a given mapicgc-gl-js topic, and enumerates the topic space. It does not distinguish itself from siblings like get_started, get_api, or search_docs, so an agent must infer the split.

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

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

Usage is only implied by 'per a un tema concret' — the agent can guess this is for copy-paste-ready samples rather than reference docs, but no explicit when-to-use or when-to-prefer-get_api/get_started is given despite obvious sibling overlap.

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

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

No annotations are provided, so the description carries the burden. It clearly discloses what the tool returns—installation instructions and a minimal functional map example—which implies a read-only retrieval operation, though it does not explicitly state that there are no side effects.

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

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

The description is two sentences, front-loaded with the concrete deliverables and followed by a concise usage cue. Every sentence earns its place with no redundancy.

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

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

For a zero-parameter retrieval tool with no output schema and no annotations, the description is nearly complete: it explains what is returned and when to use it. The main gap is that it does not explicitly differentiate this tool from get_example, which also sounds example-oriented.

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

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

The tool has zero parameters, so there are no parameter semantics to explain. The baseline for a parameterless tool is 4, and the description appropriately focuses on output content instead.

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: it returns installation instructions (NPM and CDN) plus a minimal working map example using mapicgc-gl-js. This is clear enough for an agent to understand the tool, though it does not explicitly distinguish the content from sibling tools like get_example or search_docs.

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

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

It gives a clear usage context: useful as a first step when someone wants to start a new project with the library. It does not state when not to use it or name alternatives, but the intended scenario is 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?

With no annotations, the description carries the full burden and does disclose useful behavior: it queries live configuration and falls back to a local backup if the network fails. It still omits auth/permission needs, rate limits, and the exact shape or size of the returned configuration.

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 definition is a single dense sentence that front-loads the live-query behavior and then lists the returned resource categories. There is no filler, and the parenthetical fallback note 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 listing tool with no output schema, the description names the returned categories and the network-fallback behavior. It does not describe the structure of the returned configuration in detail, but it is otherwise complete enough for an agent to call it correctly.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameter semantics, and it correctly focuses on the returned resources instead.

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 ('Consulta en viu ... i retorna') and enumerates the resources returned: base map styles, 3D terrains, and layer groups. It is clear what the tool does, though it does not explicitly distinguish itself from the documentation-oriented sibling tools.

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

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

Usage is implied by 'disponibles per usar amb mapicgc-gl-js' and the live/fallback behavior, suggesting this is for retrieving current ICGC configuration. However, it gives no explicit when-to-use versus alternatives such as get_api or search_docs, and no exclusions.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does well on scope (all packaged docs) and on output (relevant fragments with source file), and 'paraules clau' signals keyword rather than semantic matching. It says nothing about ranking, result volume beyond the limit param, or whether results are truncated, which matters for a search tool with no annotation coverage.

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

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

Two sentences with no waste: the first covers what is searched and what comes back, the second covers when to reach for it. The constraint/use case is front-loaded and nothing is repeated from the schema.

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

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

With 2 flat parameters, an output-schema-less return value that is described, and no nested objects, the definition is nearly sufficient to call the tool correctly. The remaining gap is that it does not indicate result volume behaviour or that the tool covers only packaged docs of this one library, which would help an agent avoid expecting external or version-specific sources.

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 carry their own descriptions including a default and an example for query, so the schema does the heavy lifting. The description's only contribution is the phrase 'paraules clau', which matches the query param without adding syntax or format detail. 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?

States a specific verb (cerca per paraules clau) and an explicit resource scope: the entire packaged documentation of mapicgc-gl-js, enumerated as README, API reference and examples. It also states the return shape (most relevant fragments plus source file). It stops short of naming the sibling it contrasts with (get_api, get_example), so it is clear but not fully differentiated.

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

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

Gives an explicit triggering condition: use it to find information when you don't know the exact name of a method or topic. That condition implicitly routes exact-name lookups to get_api/get_example, but those siblings are never named and no when-not guidance is given.

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