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

No annotations are provided, so the description carries the full burden, and it does disclose the shape of what comes back: a class page plus a settings table with defaults, optionally extended with private/read-only settings. It omits any note on behavior for invalid class names, response size, or formatting, which keeps it short of full 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?

Three sentences, front-loaded with what the tool returns and why it matters, then the input convention. The trailing example list ('XYCursor', 'Tooltip', 'PieSeries', 'AxisRendererX') largely duplicates the schema examples, a small redundancy but not enough to hurt readability.

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

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

With no output schema, the description must convey the return shape, and it does: class page plus settings table with defaults, plus the optional private table. It stops short of describing the rendered format or size of the reference, but for a read-only documentation lookup that is a minor omission.

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

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

Schema description coverage is 100%, so both parameters are already documented (including the casing-insensitivity and the includePrivate default of false). The description adds only a restatement of the casing rule and an implicit hint that includePrivate surfaces read-only settings, which is baseline-level added value.

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

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

States a specific verb and resource ('Get the per-class API reference for an amCharts 5 class') and enumerates what that payload contains (class page + settings table with defaults + optional private settings). The 'per-class' grain implicitly separates it from sibling reference tools, but it never explicitly contrasts itself with get_chart_reference or get_core_reference, which look like competing reference endpoints.

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

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

Gives a clear reason to reach for this tool: it is 'the authoritative source for exact setting names and default values,' with concrete examples (cornerRadius, axis `visible` default). It does not state when to prefer a sibling reference tool or what to do when the class is unknown/not found, so there are no exclusions or alternatives.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only documentation lookup, which is inherently low-risk, but discloses nothing about volume, pagination, or output size for what is billed as 'full reference documentation.'

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 filler, with the core action front-loaded and the prerequisite sequencing placed second. Every clause earns its place.

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

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

For a single-parameter, read-only documentation fetch with no output schema, the definition covers what an agent needs to invoke it correctly. It could go slightly further by noting that the response is a large reference document rather than a short answer, which would help an agent decide between this and a search tool.

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

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

Schema description coverage is 100%, so the chartType keyword and its example values are already documented in the schema. The description adds only the routing hint to list_chart_types, which is a usage rather than a semantic contribution. 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 (Get) and resource (full reference documentation for a specific amCharts 5 chart type). The scope 'chart type' distinguishes it from general-purpose siblings like get_doc, get_api_reference, and get_section without needing to open a schema.

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

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

Explicitly prescribes the workflow: 'Use list_chart_types first to see available types,' naming the sibling that supplies valid values. It does not, however, say when to prefer this over get_api_reference or get_core_reference for overlapping reference needs.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses scope (setup, colors, themes, legends, tooltips, events, data, adapters, disposal, pitfalls), which is useful content context. However, it doesn't state the format of the return, whether it's static text or paginated, or size considerations. For a zero-parameter read tool with no annotations, 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?

Two sentences, front-loaded with the resource name, followed by the content scope and usage directive. No waste; every sentence earns its place.

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

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

For a zero-parameter read tool with no annotations and no output schema, the description covers what the resource is, what it contains, and when to use it. The only minor gap is not describing the return format, but the content scope list effectively communicates what the agent will get.

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

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

Zero parameters, so baseline 4 applies. The description doesn't need to explain parameters, and schema coverage is 100% (trivially, since there are no params). No param semantics 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?

States a specific verb (Get) and resource (core amCharts 5 reference, SKILL.md), and names the sibling tools it precedes (chart-specific references). An agent can distinguish it from get_chart_reference or get_api_reference immediately.

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 states when to use it: 'Read this first before any chart-specific reference.' This is a clear sequencing directive that distinguishes it from the other reference 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.

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 conveys that this returns a complete page and that paths must match source labels exactly as printed by search tools, but says nothing about read-only nature, response shape, or pagination. Adequate but with clear gaps for an unannotated 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 compact sentences: the scope/forms are front-loaded and the workflow hint follows. No filler.

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

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

For a single-parameter read tool with no output schema, the description covers what it returns (a full page), the accepted path forms, and how to obtain a valid path. Minor gap is not naming get_api_reference as the alternative for class settings, which lives only in the schema.

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

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

Schema coverage is already 100% and includes examples and the skill-file form, so the baseline is 3. The description adds genuine meaning beyond the schema by specifying that the path must be the source label exactly as search_docs / search_all print it, clarifying an otherwise implicit matching rule.

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 ('Get a full documentation page') and enumerates the two accepted path forms (extended doc vs. 'skill/<name>'). It does not explicitly differentiate from the sibling get_api_reference, which is only distinguished inside the parameter schema, not the description.

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 clear workflow guidance: 'Use search_all first to find the right path,' which establishes this as a follow-up retrieval tool. It lacks an explicit when-not statement (e.g., when to prefer get_api_reference instead), but the sequencing advice is concrete.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the shape of the return value ('full code', i.e. complete source rather than metadata), which is useful, but says nothing about behavior on an invalid path, whether results are cached, or size limits. 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?

Two short sentences with zero filler; the purpose is front-loaded and the prerequisite follows immediately. Every clause earns its place.

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

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

For a one-parameter retrieval tool with no output schema, the description covers purpose, input provenance, and the nature of the returned content ('full code'). It stops short of noting what happens if the path is wrong or nonexistent, a minor gap for a tool this simple.

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 supplies concrete path examples ('examples/flow/sankey-diagram'), so the baseline is 3. The description adds only that the path comes from list_examples or search_all, which is routing context rather than new parameter semantics.

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 precise verb+resource ('Get the full code for a specific amCharts 5 example/demo') and scopes it to a single example, which cleanly separates it from list_examples (enumeration) and get_doc/get_api_reference (reference material). An agent can pick this tool without opening the schema.

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

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

Explicitly names the prerequisite discovery tools ('Use list_examples or search_all to find the path'), telling the agent both when to use this tool and how to obtain its required input. Nothing about routing is left to inference.

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

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

With no annotations, the description carries the full burden. 'Get' implies a non-destructive read, and it usefully discloses that the returned artifact is a minimal, customizable template, but it says nothing about permissions, rate limits, or whether the template is static versus generated.

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

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

One front-loaded sentence with an em-dash clause that earns its place by clarifying the kind of example returned. 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 simple two-parameter read tool with a fully documented schema and no output schema, the description covers purpose and the nature of the return value. The one gap is not distinguishing itself from the overlapping example/reference siblings.

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

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

Schema description coverage is 100%, including a detailed enum explanation for 'format' ('html' with CDN scripts vs 'esm' imports). The description adds no syntax or value guidance for 'chartType' beyond 'specific chart type,' 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?

States a specific verb+resource ('Get a quick-start template') and constrains it to a chart type, then characterizes the output as 'a minimal working example ready to customize.' That differentiates it somewhat from siblings like get_example or get_chart_reference, but it never names or contrasts with them explicitly.

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

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

Usage is implied: an agent can infer this is the tool to reach for when it needs a starter template for a chart type. There is no explicit when-to-use, when-not, or routing to alternatives such as get_example or list_examples.

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

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

No annotations exist, so the description carries the full behavioral burden. It usefully discloses that it returns the complete (untruncated) section text — the key behavioral fact for its primary use case — but says nothing about failure modes (heading not found, ambiguous/multi-match headings) or how many sections can be returned per heading match.

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

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

Two compact sentences with the core purpose front-loaded before the usage hint. The file-format enumeration is somewhat redundant with the schema and could be trimmed, but overall density is high with no filler.

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

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

For a 2-param, no-annotation, no-output-schema tool, the description covers purpose, primary use case, and accepted input forms. The main gap is edge-case behavior — what happens when the heading matches nothing or matches multiple sections — which is not covered anywhere.

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 both parameters are already documented in the schema, making 3 the baseline. The description's discussion of accepted file formats ('skill/SKILL.md', bare skill names, optional prefixes) largely restates the schema's own file description rather than adding new semantics.

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

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

Specific verb + resource + scope: 'Get the FULL text of one section of a doc by heading.' The word 'FULL' explicitly distinguishes it from the truncated snippets returned by search_docs/search_all, and the tool's role versus the broader get_doc sibling is inferable from 'one section ... by heading.'

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?

States a concrete use case: 'use it to expand a truncated search_docs / search_all result,' which names the alternatives and the condition that selects this tool. It does not, however, say when to prefer get_doc (whole document) over this section-level tool, so the routing guidance is one-sided.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the shape of the result (types with categories and reference file names), but says nothing about pagination, ordering, or scope limits. For a zero-parameter read-only listing the risk is low, so 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?

A single front-loaded sentence with no filler. The verb and resource lead, and the return content follows immediately.

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

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

With no output schema, the description correctly compensates by naming what is returned (categories, reference file names). For a no-parameter enumeration tool this is nearly complete; only the absence of any alternative-routing hint keeps it from a 5.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies; no syntax or format details are needed.

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

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

States a specific verb (List) and resource (amCharts 5 chart types), plus what each entry contains (categories, reference file names). It is clear on its own, but does not differentiate from siblings like get_chart_reference or list_examples that also surface chart-related content.

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

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

Usage is only implied: an agent can infer this is the discovery/enumeration entry point for chart types. There is no explicit when-to-use, when-not-to-use, or pointer to alternatives such as get_chart_reference for detailed content.

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

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

No annotations are provided, so the description carries the full burden: it says nothing about return shape, ordering, pagination, or whether the output is static bundled content or fetched remotely. It is a low-risk read-only listing, but the behavioral surface is largely undisclosed.

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

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

A single sentence with the action front-loaded and no filler; everything stated earns its place.

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

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

With no output schema, the description should ideally hint at what a listed example looks like (name/id/category) so the agent knows how to chain into get_example. For a one-optional-parameter list tool it is serviceable, but the return-value handoff is missing.

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

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

Schema description coverage is 100% and the category parameter already enumerates the valid values, so the schema does the heavy lifting. The description only restates that filtering exists, adding no format or matching semantics beyond the schema.

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

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

States a specific verb and resource ('List all available amCharts 5 code examples') plus the optional scope of filtering, which clearly separates it from the singular sibling get_example. It does not explicitly name a sibling, but the verb+resource combination is unambiguous.

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

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

The phrase 'optionally filtered by category' implies browsing vs. narrowing usage, but there is no explicit when-to-use guidance or routing to alternatives such as search_all, search_docs, or get_example. The agent must infer that this is for enumeration rather than lookup.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the index scope (skill references, documentation, code examples), but says nothing about ranking, result format, truncation, or that only maxResults results are returned, which matters for a search tool with no output schema.

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

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

Two short sentences, zero waste, with the scope statement front-loaded before the usage hint. Every sentence earns its place.

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

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

For a two-parameter search tool with no annotations and no output schema, the scope of the search is adequately described, but return behavior (result shape, ranking, pagination/limit semantics) is left entirely implicit. It is minimally viable but not complete.

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

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

Schema description coverage is 100%, so both parameters (query, maxResults) are already fully documented in the schema. The description adds no syntax, format, or query-language guidance beyond what the schema provides, 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?

States a specific verb (Search) and resource set (all amCharts 5 content: skill references, docs, code examples), which is more precise than a bare 'search' tool. It implicitly differentiates from the narrower sibling search_docs via 'ALL' and 'broad searches across everything', though it never names that sibling explicitly.

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

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

'Use this for broad searches across everything' gives implied usage guidance, contrasting with narrower searches. However, it never names the alternative tool (search_docs) or states a when-not-to-use condition, leaving the agent to infer the routing.

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

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

No annotations are present, so the description carries the burden, and it discloses the critical behavioral trait: the default search is scoped to the skill layer only and misses per-class API reference and DEFAULTS content. It also implies a ranked-sections return shape. It stops short of describing result structure or limits in detail, but for a read-only search the key caveat is covered.

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

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

Two sentences, front-loaded with purpose before the caveat, with no filler content. The NOTE sentence is dense with sibling names and examples (cornerRadius, strokeDasharray) that slightly outweigh what an agent needs to decide whether to call the tool.

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

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

With no output schema, the description explains what is returned ('matching sections ranked by relevance') and covers the main behavioral gap (skill-only default scope). It is nearly complete for a 3-parameter search tool, missing only finer return details such as result fields or truncation 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% and both scope and maxResults already carry descriptions, so the baseline is 3. The description reinforces the meaning of the scope default (what extended docs contain and why they matter), which is useful context but not syntax or format beyond the schema.

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

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

States a specific verb and resource ('Search the curated amCharts 5 skill docs (SKILL.md + chart references) for a keyword or topic') and adds the return semantics ('matching sections ranked by relevance'). The NOTE distinguishes it from sibling tools such as search_all, get_api_reference and get_doc by naming exactly where each reaches.

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 states the default behavior ('by default this scans ONLY the skill layer'), the condition under which the default is insufficient, and the concrete alternatives to select instead (pass scope:'all', or use search_all / get_api_reference / get_doc).

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