MIAN

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 the return shape (ids, why they match, traits) and that results are ranked. However it says nothing about the limit parameter's effect, result count, or any read-only/permission characteristics.

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 dense sentence with embedded examples; the core action is front-loaded and there is little waste. The parenthetical examples are long but they are the most informative part.

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?

Since there is no output schema, describing the return values is valuable, and the description does so. But it omits the limit parameter entirely and gives no guidance on result volume, leaving the definition partially incomplete for a 2-parameter 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 0% for both parameters. The description only conveys meaning for 'query' via the example briefs; the 'limit' parameter (1-12) is never mentioned, so a meaningful half of the schema remains undocumented.

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+resource: it ranks design languages against a style brief. This distinguishes it from siblings like list_noodles (enumerate) and get_noodle (fetch one), though the tool name's 'noodles' jargon is only implicitly decoded as 'design languages'.

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?

Two concrete example briefs imply when the tool is appropriate, but there is no explicit when-to-use vs. alternatives such as list_noodles or get_design_language, 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?

No annotations are provided, so the description bears full behavioral burden. It does add genuinely useful substance about the return content — guarantees the component makes plus author responsibilities — which is more than the schema reveals. However it says nothing about output format, whether the notes are per-component static docs, or any other behavioral 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 short sentence that is front-loaded and wastes no words, so it is structurally clean. But the brevity here reads as under-specification rather than tight conciseness, since the sentence carries no usage, parameter, or format 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?

With no annotations, no output schema, and 0% parameter coverage, the description needs to carry most of the load for a documentation-retrieval tool. It explains the topic of the returned text but omits format, scope per component, and when it matters relative to the other get_* tools, leaving significant 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 0%, so the single required 'id' parameter is documented nowhere. The large enum self-documents the valid values, and the phrase 'the component' weakly ties id to a component identifier, but the description adds no explanation of what id means or how to choose it beyond the enum list itself.

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 is a noun fragment ('What the component guarantees and what the page author must do') that conveys the content of the notes but never states the action or resource explicitly — the verb 'get' lives only in the name/title. Combined with the title 'Accessibility notes' an agent can infer it returns accessibility obligations for a component, but it is not a clean verb+resource statement and does nothing to distinguish it from siblings like get_component or get_design_language.

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 call this tool versus get_component, get_component_source, or get_design_language. The only signal is the implicit 'the component', which suggests it is scoped to a component id, but no trigger condition or alternative is named.

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

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

With no annotations, the description carries the burden, and it does disclose the return payload (classes, accessibility notes, example HTML), which is genuinely useful read-side context. However it says nothing about permissions, caching, pagination, or failure behavior.

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

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

One short, front-loaded sentence with no filler — efficient. It is arguably too terse, omitting a verb and any routing hint, but nothing in it 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 simple read-only fetch with well-populated enum and no output schema, the description covers the essentials of what comes back. It falls short on disambiguating from the many sibling tools and on any usage conditions.

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 0%, but the single 'id' parameter has a large self-documenting enum of component slugs, and 'one component' implies the id selects a single item. The description adds no syntax, format, or default detail beyond what the enum already conveys, so this is baseline-adequate rather than compensating.

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

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

The description names the resource ('one component') and enumerates the payload it returns: classes, accessibility notes, and example HTML. That is a clear, specific purpose, though it is a noun phrase with no verb and does not explicitly contrast with overlapping siblings like get_component_source or get_example.

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

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

There is no guidance on when to use this tool versus the several closely related siblings (get_component_source, get_accessibility_notes, get_example). An agent must infer that this is the bundled 'everything about one component' call rather than the narrower ones.

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 a genuine behavioral trait beyond structure: JS is only included when the component has behaviour. But it omits the read-only nature, the output format (raw source vs. wrapped text), whether results are cached or large, and how the 'part' parameter affects what comes back.

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, which is appropriate for this tool. It is slightly undermined by the typo 'mian.js', which momentarily obscures the referenced artifact.

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 annotations, no output schema, and two parameters at 0% schema coverage, the description is too thin. An agent cannot tell whether the response is a single blob, separated CSS/JS fields, or how 'part' selects between them, nor how this differs from sibling 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 0%, so the description must compensate. It gestures at the two content kinds (CSS and main.js), which partially maps to the css/js/both enum, but the 'part' parameter is never named or explained, and the large id enum receives no framing beyond the implicit vocabulary of 'component'.

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 what is returned (the component's CSS, plus its portion of main.js when it has behaviour), so the resource and content type are identifiable. However, it never names the action or distinguishes itself from close siblings like get_component, get_noodle_css, or get_accessibility_notes, leaving the agent to infer that this returns raw source rather than API documentation or usage examples.

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 when-to-use guidance and no mention of alternatives. With siblings such as get_component and get_noodle_css available, the description gives the agent no basis for choosing this tool over them, nor any stated prerequisites for the id.

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 disclose the shape of the returned content (rules plus a CSS recipe), which is meaningful output transparency, but says nothing about read/write nature, permissions, or limits. The 'get_' prefix weakly implies read-only, so this is adequate but thin for a bare-annotation 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 tight sentence that front-loads the returned content and ends with the use case. Nothing is wasted, though the dash-clause and heavy comma list make it dense to parse.

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

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

With no output schema and no annotations, the description must do more, and it does characterize the return bundle well. However, the load-bearing term 'noodle' is undefined domain jargon and the 58-value enum is left unexplained, so an agent still needs other tools (e.g. get_noodle, list_noodles) to interpret the identifier it must pass.

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 0% and the single 'id' parameter is an enum of 58 opaque values (mian, yangchun, shio, ...). The description only says 'of one noodle', telling the agent the id selects a noodle but never explaining what these values signify or how to choose among them. For a 0%-covered, jargon-term parameter, this leaves a real gap.

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 resource and enumerates its contents (philosophy, principles, shape/surface/colour/type/motion/data rules, extension rules, CSS recipe) of one noodle. This is clear enough to distinguish from get_component or get_template, though it does not explicitly name its closest siblings get_noodle and get_noodle_css, whose surface it partly overlaps with via the 'CSS recipe' mention.

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

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

Provides a concrete when-to-use: 'use it to design components MIAN does not ship in exactly that style.' That is a real selection condition that routes the agent to this tool rather than a shipped-component tool. It names no alternatives or exclusions, so it stops short of a full when/when-not statement.

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 discloses the output shape (a complete, runnable HTML page) and that the agent must save and open it, but says nothing about whether the HTML is self-contained, how large it may be, whether it requires prior setup, or any limits on generating pages.

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, front-loaded with the output description and followed by the action to take. There is no filler, though the extreme brevity is what creates the coverage gaps rather than a model of efficient completeness.

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

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

For a tool with four parameters, low schema coverage, no annotations, and no output schema, the two-line description is substantially under-specified. An agent would not know how to choose noodle/mode values, how to obtain multiple examples, or what the returned page assumes about its environment.

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 only 25% (just the 'example' index), so the description should compensate. It names noodle and mode implicitly and conveys that both are freely selectable, but never explains what a 'noodle' means, what happens when it or mode is omitted, or how 'example' selects among multiple examples — leaving three enum parameters semantically opaque.

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 concrete verb+resource: it returns a complete HTML page rendering the requested component. It adds the scoping detail that the page can be produced for a chosen noodle (theme/variant) and mode, which separates it from a source-snippet tool, though it never names a sibling like get_component or get_component_source 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?

'Save and open it' is a light usage hint but there is no guidance on when to pick this over the many sibling tools (get_component, get_component_source, get_template, get_noodle_css). Nothing says when to omit vs. supply noodle/mode, or what to do with the result beyond saving it.

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

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

With no annotations, the description carries the full burden, and it does disclose the breadth of the return payload ('every token... light and dark, plus its design principles'), which is genuinely useful scope information. It says nothing about permissions, read-only nature, response size, or caching, but for a read-only 'get' verb the disclosed content scope partially compensates.

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 dense sentence with zero filler, front-loading the resource and the payload scope. Nothing in it is redundant with the name or title.

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, no annotations, and 0% parameter coverage mean the description must do the work, yet it never explains the id enum or routes the agent to find_noodles/list_noodles for valid ids. For a tool with a 59-value opaque enum this leaves a significant 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 0% and the single required parameter 'id' is an unlabeled enum of 59 opaque codenames (mian, ramen, udon, pho...). The description adds no meaning to this parameter, not even clarifying that the id selects a design system or pointing to how valid values are discovered.

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 decodes the opaque codename 'noodle' by stating it returns every token of a design system (light and dark) plus design principles, so an agent knows what the payload contains even though the name alone is meaningless. However, it offers no differentiation from closely named siblings such as get_noodle_css, list_noodles, or find_noodles.

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 list_noodles, find_noodles, or get_noodle_css. The agent must infer from the name and description alone that this is the single-system fetch, and no prerequisites or exclusions are given.

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 and no output schema, the description carries the full burden. It discloses only that output is a CSS block; nothing about what happens for an invalid id, whether the block is complete or partial, auth requirements, or whether the operation is read-only.

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 resource and output form arrive immediately. It is arguably too terse to stand alone, but there is no wasted wording.

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-param tool with no annotations and no output schema, the description leaves key gaps: the meaning/derivation of the id, and any behavioral context for the returned CSS block. It conveys the output type but little else an agent needs to invoke it confidently.

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 0% and the sole required parameter has no documented meaning. "One noodle's" weakly implies the id selects a noodle, but the description never explains that the id must be one of the enumerated noodle names (or where to obtain it), leaving the schema's enum as the only signal.

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 resource (a noodle's design tokens) and output form (a CSS block), which distinguishes it from sibling get_noodle and the list/find tools that operate on noodles as entities. It stops short of naming the alternative sibling, so it's clear but not explicitly 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?

"to vendor or customise" hints at the use case and implies this is the tool for exportable CSS rather than raw token data, but it never states when to prefer this over get_noodle or how the id relates to results from list_noodles/find_noodles. Usage is implied rather than instructed.

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 and no output schema, so the description carries the full disclosure burden, yet it only says it answers 'how to'. It does not say whether it returns code, commands, or prose, whether the operation is read-only, or what happens when an unsupported stack/noodle combination is requested.

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 short sentence with no padding, which is good, but it is a fragment that omits the details an agent needs, so brevity is partly under-specification rather than tightness.

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 annotations, no output schema, and two undocumented enum parameters, one sentence is not enough. An agent cannot tell what it receives back or which noodle/stack combinations are valid.

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 0%; the description accounts for 'stack' only implicitly and says nothing about the second parameter, noodle, which has a 60-value enum with no explanation of its meaning or default. Enum values help but do not explain interaction between stack and noodle.

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 resource (setup/install instructions) and scopes it to a stack, so an agent can tell this apart from get_component or get_example. The wording 'add MIAN to a project' is slightly narrower than the schema's noodle enum, which lists ~60 options, so the scope may mislead an agent into thinking only MIAN is supported.

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 choose this over get_site_guide, get_example, or get_noodle, and no mention of prerequisites, ordering, or what to do with the returned instructions. The 'given stack' phrasing is the only contextual hook.

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 adequately describes the tool's behavior by detailing the guide's content (process, principles, page anatomies, etc.). It does not explicitly state that the operation is read-only or non-destructive, but the 'get_site_guide' name and guide-focused description make that clear.

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 front-loaded with the main purpose and then lists the guide's contents efficiently. The second sentence about narrowing is short and actionable. While the list of contents is dense, every element earns its place by describing what the guide covers.

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

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

Given the absence of annotations and output schema, the description sufficiently explains the guide's scope and how to filter it. It does not cover return format or default behavior, but for a documentation-retrieval tool this is adequate. The main gap is the lack of detailed parameter semantics for the enum parameters.

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

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

Schema description coverage is only 33%, so the description must compensate. It says to 'Narrow it with page_type and noodle,' which adds meaning by indicating these parameters filter the guide. However, it does not explain the enum values, default behavior when parameters are omitted, or the effect of the brief parameter beyond what the schema already provides.

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

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

The description clearly states the resource is a comprehensive guide for designing a whole website with MIAN, and lists its components (process, principles, page anatomies, composition, checklist). It distinguishes itself from sibling tools like get_noodle or get_component by focusing on the entire design process, though it does not explicitly name alternatives.

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

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

The description provides a clear context for when to use the tool: when designing a whole website that should not look generated. It also advises how to narrow results with page_type and noodle. However, it does not explicitly state when to use this versus related tools such as get_design_language or plan_site, and offers 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?

With no annotations, the description carries the full behavioral burden. It discloses that the result includes design notes and complete HTML and that omitting page returns all pages, but it omits read-only status, permissions, error behavior, return packaging, and what 'save each page as .html' means operationally.

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

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

The definition is very short and front-loads the output content. The second sentence is directive ('Save each page as .html') and may be useful, but the overall brevity leaves key semantics unexplained.

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 four-parameter tool with large enums, no output schema, and no annotations, the description is under-specified. It does not explain the return shape when all pages are requested, how design notes are formatted, or any operational constraints.

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 only 25%, so the description should compensate, but it adds little beyond the schema. It restates that page can mean one page or all pages (already in the schema) and mentions noodle/mode without explaining what a noodle is, what mode auto does, or how id maps to the enum 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?

The description names the resource (a template) and the payloads (design notes and complete HTML for one or all pages), and the title reinforces the getter role. It is clear enough to distinguish at a high level from list_templates or get_noodle, but it does not explicitly differentiate itself from the many sibling retrieval tools.

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

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

No when-to-use or when-not-to-use guidance is provided. It does not explain when to choose get_template over get_noodle, get_noodle_css, get_design_language, or list_templates, nor does it state prerequisites for the required template id.

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 the return payload shape (category plus a one-line description) for each component. It says nothing about volume, pagination, ordering, or read-only nature, so the behavioral picture remains 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 short sentences with zero filler, and the scope statement is front-loaded ahead of the optional filter. Nothing redundant is included.

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

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

For a simple read-only catalog listing with one enum parameter and no output schema, the description covers scope, filter, and return content. The main omission is disambiguation against the several sibling listing/search 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?

Only one parameter, whose enum already enumerates the eight valid categories in the schema. The description adds the word 'optionally' (confirming the filter is not required) but no additional semantics beyond what the enum provides.

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

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

States a specific resource (all MIAN components) and what is returned (category and one-line description), which distinguishes it from a targeted lookup. It does not, however, name the obvious sibling search_components or explain the division of labor between listing and searching, so the differentiation is only 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?

The description implies the use case: enumerate the full catalog, with an optional category narrowing. It offers no explicit when-to-use guidance against search_components, get_component, or list_noodles, leaving the agent to infer which tool to pick.

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 the result structure (grouped by family, with inspiration and appearance/motion), which is useful, but it omits whether the operation is read-only, whether results are paginated, and whether any auth or limits apply. For a plain list tool this is adequate but leaves 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?

A single tight sentence with no filler; the grouping and content details are front-loaded. It loses a point only because the sentence fragment lacks an explicit action verb, slightly softening the statement of what the tool does.

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

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

The tool is simple (one optional enum param, no output schema, no annotations), and the description covers the output grouping and fields. It still leaves the parameter's filtering semantics and any usage context unstated, so it is minimally viable rather than 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 0%, so the description must compensate for the single 'family' parameter. It does not: 'grouped by family' hints at grouping but gives no indication that 'family' is an optional enum filter, nor how the enum values (Minimal, Flat, Pixel, etc.) behave in the response.

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 identifies the resource ('The design systems'), states how they are grouped ('by family'), and outlines the content ('what each is inspired by and how it looks and moves'). However, it never differentiates this from siblings like find_noodles or get_noodle, leaving the agent to infer which listing/search tool to pick.

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 when-to-use guidance, no when-not-to-use, and no mention of an alternative tool. The description is purely descriptive of the output, so the agent gets no routing help against find_noodles or get_noodle.

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 supplied, the description carries the full burden. It usefully discloses that templates are composed only of MIAN sections/components and carry a default noodle and pages, giving structural context beyond the name. However it says nothing about permissions, whether the list is paginated/complete, or freshness of the catalog.

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 key fact (whole multi-page websites) before the category enumeration. The parenthetical category list is long but serves selection value by signaling coverage breadth.

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 list tool with no output schema, the description should convey what comes back. It hints at structure (default noodle, pages) but does not say the response is a catalog of all available templates or how they are identified for a subsequent get_template call.

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

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

The input schema has zero parameters and 100% coverage, so there are no parameter semantics for the description to add. Baseline 4 applies; the description neither misleads nor duplicates any schema field.

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 characterizes the resource precisely: whole multi-page websites built from MIAN sections and components, enumerating ten template categories (SaaS, docs, restaurant, magazine, etc.). Combined with the name 'list_templates' and the singular sibling 'get_template', an agent can distinguish this from component/noodle-level tools, though the description itself never states the verb 'list'.

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 when-to-use guidance: nothing says whether to call this before plan_site, instead of get_template, or how it relates to list_noodles and list_components. The only implicit cue is the word 'whole', which suggests site-level rather than section-level lookup, but that is left for the agent to infer.

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 two useful traits: the plan is deterministic (same brief yields the same plan) and it returns a "what to read next" pointer, implying a guided workflow. It says nothing about whether it writes anything, requires auth, has latency limits, or how it fails on an unknown site type.

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 dense sentence enumerating the deliverables, followed by a short routing sentence. The purpose is front-loaded and nothing is filler, though the colon-separated output list reads like a compressed manifest rather than prose.

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, and the description partially compensates by listing what the plan contains, which is genuinely helpful. Against that, six undocumented enum parameters and no side-effect or prerequisite information leave real gaps for a 9-parameter planning tool.

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

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

Schema coverage is only 33% across 9 parameters: type, needs and style are documented in the schema, but the six enum knobs (cards, rhythm, density, surprise, asymmetry, repetition) have no descriptions anywhere. The description's "from a brief" and mention of "composition direction" hint that those knobs shape the composition, but it adds no per-parameter meaning, so it fails to compensate for the coverage gap.

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 (plan) and resource (site) and then enumerates the concrete artifacts returned: recommended noodles, closest template, page outlines with real component ids, composition direction, rules. This clearly distinguishes it from narrower siblings like get_template, find_noodles and get_noodle, which each return a single piece of that plan.

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?

"Start here for any whole website" gives an explicit entry-point condition for the whole-site case, which is the primary routing decision against the other 16 siblings. It does not, however, state a when-not condition or name the alternative to use for partial tasks (e.g. get_component or get_template for a single artifact).

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 that results are ranked, which is useful, but omits return format, ranking criteria, result limits, and whether the operation is read-only.

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

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

The description is a single front-loaded sentence with no wasted words. The examples are compact and directly illustrate the kind of query the tool expects.

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 search tool with no annotations and no output schema, the description is too sparse. It does not say what the ranked results contain or how the limit affects them, leaving important invocation context 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 0%, so the description must compensate. The examples add meaning to the required 'query' parameter by showing expected intent phrases, but the 'limit' parameter and its 1–25 bound are not addressed.

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, 'ranked search', and the resource is clear from the tool name and title. The examples of intent phrases make the purpose concrete, but it does not differentiate this tool from siblings like list_components or get_component.

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

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

The description implies use when searching by intent, but gives no explicit when-to-use or when-not-to-use guidance. It does not mention alternatives such as list_components or get_component, leaving routing decisions to the agent.

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

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

With no annotations, the description carries the burden and does well: it discloses the exact categories of checks and mentions that suggestions are returned. It does not explicitly state that the operation is read-only or non-mutating, but 'Check' strongly implies no side effects, and the level of detail is strong for a validator.

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

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

The description is a single, front-loaded sentence that lists the checks efficiently and ends with a clear usage directive. Every clause earns its place with no redundancy.

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

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

Given the low complexity, high schema coverage, and absence of an output schema, the description is nearly complete: it covers the checks performed and notes suggestions. It could add a brief note about the return shape (e.g., list of issues) to be fully self-contained.

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 'html' parameter is fully documented in the schema. The description adds no parameter-specific meaning 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?

The description states a specific verb ('Check') and resource ('HTML' / 'MIAN markup'), then enumerates exactly what is validated: unknown mn- classes, noodle ids, data-mn attributes, asset paths, missing stylesheet/script, and hard-coded colours. This clearly distinguishes it from all sibling tools, which are retrieval, listing, or planning tools.

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

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

The instruction 'Run before finishing' provides clear timing context for when to use the tool. However, it does not name alternatives or explicitly state when not to use it, so it falls short of a full 5.

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