Systra Tools

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 implies a read operation and describes the return as complete source, but does not state read-only safety, error behavior for missing components, or any other operational trait.

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 wasted words. Every part earns its place by specifying the return type and the lookup key.

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 tool with full schema coverage and no output schema, the description is minimally adequate. However, it omits differentiation from get_component_styled and does not clarify what 'complete, copy-ready' means for callers needing to choose between component retrieval tools.

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 single name parameter is fully documented in the schema. The description only repeats 'by its name' and adds no syntax, matching rules, or formatting details beyond the schema 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?

States a specific verb and resource: returns the complete, copy-ready React/TSX source of a component by name. Clear what it does, but it does not distinguish itself from the sibling get_component_styled.

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

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

No guidance on when to use this versus alternatives such as get_component_styled, list_components, or search_components. The description only states what the tool does, leaving selection entirely 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 behavioral burden. It does disclose what is returned (component + tokens + adaptation instructions), which is meaningful since there is no output schema, but it says nothing about failure modes (e.g., an unknown style slug), auth requirements, or whether the instructions are prescriptive or advisory.

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

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

A single front-loaded sentence with the return content stated first. The trailing clause "so the component lands directly in your own brand look" is mildly promotional rather than informative, keeping it short of a 5.

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 read tool with no annotations and no output schema, the description covers the essence of what comes back but omits how the returned tokens/instructions should be applied, what happens on an invalid style, and how this differs from the plain get_component. Adequate but with clear gaps.

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

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

Schema description coverage is 100% and both parameters are documented (component name example, style slug sourced from list_styles). The description adds no syntax, format, or constraint detail beyond what the schema already provides, so the baseline 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?

States a specific verb ("Returns") and a compound resource (component + design tokens of a brand style + adaptation instructions). It is distinguishable in intent from get_component by the 'styled' framing, but it never names or contrasts with that sibling, so the differentiation is inferred rather than stated.

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

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

"so the component lands directly in your own brand look" implies the use case (you want brand-matched output rather than a raw component), but there is no explicit when-to-use instruction, no prerequisites, and no named alternative such as get_component.

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 must carry the full behavioral load. It states what is returned (HTML, export script, rules) and that it can be used to rebuild and render, which is useful, but it does not mention read-only nature, authentication requirements, or any rate limits. For a read tool with no annotations, this leaves gaps.

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 summarizes the return value and its purpose. It is front-loaded with the primary action and flows logically. Slightly more explicit differentiation from siblings could improve it, but it is tight.

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

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

No output schema exists, so the description must explain the return format, which it does at a high level (HTML file, export script, rules). However, it does not specify the exact structure of those components or how they are delivered, and with no annotations, behavioral aspects like permissions or side effects are unaddressed. Adequate but not complete.

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

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

Schema coverage is 100%, so the schema fully documents both parameters, including the enum for lang and the note that slug can be found via list_posts. The description adds no parameter details. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a clear verb and resource: it returns a post template consisting of HTML file, export script, and rules. It distinguishes itself from list_posts by returning instructions rather than metadata. It could be clearer about the exact return format and how it differs from get_component or get_recipe, which also likely return templates.

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: use when you need the full set of instructions to rebuild and render a post. There is no explicit when-to-use guidance, no mention of alternatives (e.g., get_recipe for recipes), and no prerequisites such as needing a slug from list_posts, though the schema notes that.

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 return shape (ordered sections, purpose, complete source), which is genuinely useful behavioral context, but it says nothing about read-only safety, authentication needs, or pagination/size limits for what could be a large payload.

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 that front-loads the core action and elaborates only on the returned contents. It is slightly dense in the middle clause but every element informs the agent; 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?

With no output schema, the description usefully enumerates what is returned, and parameters are fully covered by the schema. What is missing is sibling differentiation and any behavioral context (auth, size), which for a simple read tool is a modest rather than critical gap.

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, making 3 the baseline. The phrase 'Optionally in the look of a brand style' restates the optional nature of the style parameter that the schema already conveys, adding little beyond it.

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 ('Returns') and resource ('page recipe') and details what the payload contains (section sequence, per-section purpose, full source). However, it never distinguishes itself from siblings like get_component, get_component_styled, or get_style, so an agent can't fully route between them from this text alone.

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

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

Usage is only implied by the schema pointer to 'Recipe slug from list_recipes', which hints at a list-then-fetch flow. There is no explicit when-to-use vs get_component/get_style guidance and no stated prerequisites or 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?

With no annotations, the description carries the full burden. It does disclose the returned artifact set, which is useful behavioral context, but it never states that this is a non-mutating read, nor what happens for an unknown slug or whether a style must first be extracted.

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

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

One sentence, front-loaded with the verb and resource, with the enumerated payload as a compact tail. 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?

There is no output schema, so the description must convey return values, and it does so by enumerating the token categories plus DESIGN.md. The main remaining gap is error/edge-case behavior for an invalid or unextracted slug.

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 single 'slug' parameter is already documented as coming from list_styles; the description adds no syntax, format, or validation detail beyond that, which is the expected baseline when the schema does the heavy lifting.

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 ('Returns') and resource ('every design token of an extracted brand style'), then enumerates the payload (colours, typography, CSS variables, DESIGN.md). It is clear and concrete, though it never names a sibling to contrast with, so sibling differentiation is left to inference.

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

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

Usage is only implied via the slug parameter's schema note ('Style slug from list_styles'), which does hint at the prerequisite tool. There is no statement of when to use this versus get_component_styled or other lookups, 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 burden. 'Lists' implies a non-mutating read, and it discloses the payload shape (each category plus its component count), which is genuinely useful. However it says nothing about permissions, ordering, or whether empty categories are included.

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

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

One short sentence, front-loaded with the verb and the returned artifact. Every clause earns its place with no filler.

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

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

With no output schema, the description must convey the return shape and does so ('with the number of components in it'). For a zero-parameter read tool this is close to sufficient; only ordering and empty-category handling remain unspecified.

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

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

The tool takes no parameters, so the baseline is 4. There is nothing for the description to disambiguate, and it correctly conveys that the listing is unconditional ('every category').

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 ('Lists every category') and it even names the domain scope 'of Systra Tools'. It is clear what the tool returns. It does not explicitly contrast itself with siblings like list_components, though no sibling covers categories, so disambiguation is implicit.

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

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

Usage is implied by the name and description: reach for it when you need the category taxonomy. There is no explicit when-to-use or when-not-to-use guidance, and no named alternative, but the semantics are straightforward enough that an agent can infer the 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?

No annotations are provided, so the description carries the full behavioral burden. It communicates that this is a plain read/list operation with an optional narrowing filter, which is useful, but says nothing about return shape, ordering, pagination, or result size for an unfiltered call.

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 resource named first and the optional filter immediately after. Nothing to trim.

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

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

For a one-optional-parameter list tool with no output schema, the description covers what it does and how to narrow it. It would be stronger with a note on what an unfiltered call returns, but the gap is minor given the tool's simplicity.

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, but the description adds genuine value by giving concrete example slugs ('heros', 'forms', 'cta') that the schema does not supply, clarifying the expected value domain of the category filter.

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 (Lists) and resource (components of the library), and the 'list_' prefix distinguishes it from get_component and search_components. It does not explicitly name those siblings or contrast its scope against them, so it stops short of a 5.

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

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

The 'Optionally filtered by category slug' clause implies the intended usage pattern, but there is no statement of when to prefer this over search_components or get_component, and no exclusions or prerequisites.

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 provided, the description carries the full behavioral burden. It adds useful context by disclosing that returned URLs are ready and permanently valid, which goes beyond schema fields. However, it omits other relevant behavioral details such as authentication requirements, rate limits, pagination, or the exact return structure, leaving clear gaps.

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 tightly written sentences with no redundant information. It front-loads the core action and then adds the optional filtering detail. 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?

There is no output schema, so the description is responsible for explaining return values. It does state that URLs are ready and permanently valid, which is helpful. However, it does not describe the overall return structure (e.g., array, metadata fields) or pagination behavior. For a simple list tool, this is minimally adequate but leaves gaps.

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

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

Schema description coverage is 100%, so the schema already documents both parameters thoroughly, including an example for album and an enum for format. The description simply repeats that filtering by album and format is optional, adding no new semantic meaning. Baseline 3 is appropriate when the schema does the heavy lifting.

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 lists images from the Systra Tools media library. It also clarifies the key output value (ready, permanently valid URLs). However, it does not explicitly differentiate itself from sibling tools like search_images, so it falls short of the top score.

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 such as search_images. It implies usage through optional filters and the phrase 'to drop straight in', but does not state when-not to use it or name any alternative. This matches the calibration for a similar tool with no usage guidance.

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

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

With no annotations, the description carries the full burden, and it does disclose useful context: each template is a single HTML file that can be rebuilt and exported as image or video. However, it says nothing about the return shape (ids vs. file contents), whether listing is paginated, or any auth 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?

Two tight sentences, front-loaded with the core action and resource, with the template dimensions and format following immediately. Every clause carries information.

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

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

No output schema exists, so the description should ideally hint at what a 'list' returns (identifiers, names, metadata). It conveys what a template is but not what the call yields, leaving a real gap for a list tool with no annotations.

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

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

Schema description coverage is 100% and the single enum parameter (family) is fully documented there, including the meaning of 'klar' and 'editorial'. The description adds no additional parameter semantics, 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 (Lists) and resource (Instagram post templates of Systra Tools) with extra specificity (1080 x 1350). It is clearly distinguishable from siblings like list_components or get_post by resource name, but it never explicitly contrasts itself with those alternatives.

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

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

There is no statement of when to use this tool versus get_post (single post) or list_categories, and no guidance on whether the family filter should be applied. Usage is only implied by the plural name and the schema's optional family enum.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does convey the nature and domain of the returned items (curated landing-page section sequences, with examples like SaaS, coaching, hotel), but says nothing about ordering, pagination, or result size for a list 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?

A single front-loaded sentence that defines the resource first and then parenthetically illustrates it with concrete verticals. No wasted clauses, though the parenthetical could arguably be trimmed.

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

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

For a parameterless list tool with no output schema, the description explains what the returned items are, which is the main thing the agent needs. Minor gaps around result ordering or bounds keep 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 and the schema is fully described, so there is nothing for the description to compensate for. Baseline 4 applies.

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

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

States a specific verb ('Lists') and resource ('curated page recipes') and then defines what a recipe actually is ('sensible sequences of sections for complete landing pages'), which is genuinely clarifying. It does not explicitly contrast itself with the singular get_recipe sibling, so it stops short of a 5.

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

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

No explicit when-to-use statement or named alternative. The plural 'Lists' and the sibling get_recipe make the browse-vs-fetch distinction inferable, but the agent gets no stated condition for preferring this over get_recipe or search_components.

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. 'Lists' implies a read-only operation and it discloses the extracted origin of the styles, which is useful context, but it omits auth requirements, rate limits, pagination behavior, and return shape.

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 a clarifying parenthetical. Every part earns its place, and the parenthetical efficiently defines what 'brand styles' means.

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, zero-parameter list tool with no annotations and no output schema, the description identifies what is listed and its applicability to components. It does not describe return format or pagination, but those gaps are minor because invocation requires no arguments.

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

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

The tool takes zero parameters, so there are no parameter semantics to document. Schema coverage is trivially 100%, and the description adds no parameter detail because none exists. Baseline 4 applies for a 0-parameter tool.

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

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

States a specific verb 'Lists' and resource 'brand styles', and clarifies what those styles are (extracted with the style extractor, colours and fonts of real websites). It does not explicitly differentiate from the singular sibling get_style or from list_components, so it stops short of full sibling differentiation.

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

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

No explicit when-to-use, when-not-to-use, or alternatives are given. The clause 'that can be applied to components' hints at purpose but does not tell an agent when to pick this over get_style or list_components.

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

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

With no annotations, the description carries the full behavioral burden, and it discloses only that matching is against name or category. Nothing is said about result limits, ordering, case sensitivity, or what an empty result set means — meaningful gaps for a search tool.

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

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

A single front-loaded sentence covering verb, resource, and match fields, with zero filler. Slightly more (result-count or ordering behavior) could have been added without bloat, but nothing present 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-parameter read tool with no output schema and no annotations, the description is minimally viable but leaves the agent guessing about result behavior and how it relates to the many search_/list_/get_ 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 coverage is 100% and the schema already defines the single parameter as 'Search term.', so the baseline would be 3. The description adds genuine meaning by stating the term is matched against the name or the category, which the schema does not say.

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 (searches) and resource (components) plus the fields matched (name or category), which lets an agent distinguish it from get_component and list_components. It does not, however, differentiate itself from the parallel sibling search_images, which it never mentions.

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

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

No when-to-use guidance at all: it never says to prefer this over list_components when the user has a keyword, nor when a direct get_component lookup is better. The agent must infer all routing from the 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses the searched fields and that results are returned as 'ready URLs', but says nothing about result limits, pagination, matching semantics, or authentication requirements for a read 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?

One sentence, front-loaded with the verb and resource, ending with the return-shape note. No filler, though it is terse enough that usability details are absent rather than merely compact.

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 search tool with a fully documented schema, this covers purpose, matching scope, and return type. Missing pagination and empty-result behavior are minor given the tool's simplicity.

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 'query' parameter is already documented with examples. The description adds that the keyword is matched against title, file name, and album, which is genuinely beyond the schema, but it provides no syntax or multi-term 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 (searches) plus resource (media library images) and the fields searched (title, file name, album). It implicitly distinguishes itself from the list_images sibling by being keyword-driven, though it never names that alternative.

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: search by keyword versus enumerating with list_images. There is no explicit when-to-use/when-not statement, no mention of what happens if the query matches nothing, and no guidance on choosing between this and the sibling search_components.

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