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, the description carries the full behavioral burden. It does disclose useful traits: the library is entirely AI-generated, URLs are 'ready, permanently valid', and results are paged at 100 per page. It omits ordering, stability guarantees, and any auth requirements, so the disclosure is partial.

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

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

Two tight sentences with zero filler; the primary capability ('lists the images... with ready, permanently valid URLs') is front-loaded and the filtering/paging detail follows. Every clause earns its place.

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

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

For a read-only, 3-parameter optional-filter list tool with no output schema or annotations, the description covers filtering, pagination, and the nature of the returned URLs. It is nearly complete, with only minor gaps around result ordering and authentication expectations.

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 page, album, and format are already fully documented with types, enum values, and defaults. The description only restates the album/format filters and page size, adding no syntax or semantics beyond the schema; 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?

Names a specific verb and resource (lists images of the Systra Tools media library), and adds distinguishing substance: all content is AI-generated and returns permanently valid URLs. It does not, however, explicitly differentiate itself from the sibling search_images, leaving the browse-vs-search distinction to inference.

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

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

The optional album/format filters imply a faceted browse use case ('Without one, every album is returned' appears in the schema, not the description), but there is no explicit when-to-use guidance or steering toward search_images when a query-based lookup is needed. Usage is implied rather than stated.

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 burden. It does disclose the search scope (title, tags, file name, album), the return type ('ready URLs'), and pagination ('100 per page'), which is useful context, but it says nothing about result ordering, empty-result behavior, or any auth/rate constraints.

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 covers purpose, search fields, return format, and pagination without any wasted words – the verb leads and every clause earns its place.

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

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

For a two-parameter read tool with no output schema and no annotations, the description supplies search semantics, return format, and page size. It is nearly complete, only lacking detail on result ordering or page-count/termination 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 both parameters are already documented (baseline 3). The description goes one step beyond by explaining that the query term is matched against title, tags, file name, and album, adding semantic meaning not present in the schema's example values.

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 ('the media library') and clarifies the corpus ('all images AI-generated'), which cleanly separates it from list_images. It stops short of explicitly naming the sibling alternatives, so it's 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?

Usage is implied – reach for this when you need keyword search rather than enumeration – but there is no explicit 'use this when / use list_images otherwise' guidance and no exclusions or prerequisites stated.

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