MIAN

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

No annotations exist, so the description carries the full burden. It does disclose useful traits: the accent is auto-derived by colour harmony unless supplied, and the output artifacts (tokens for light and dark, usage, contrast report) are described. It does not say whether anything is persisted, whether an existing brand of the same name is overwritten, or what the response shape is.

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

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

Two sentences, front-loaded with the produced artifacts before the trigger condition, and every clause carries information. Slightly dense with the colour/derivation caveat stacked mid-sentence, but 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 11 parameters, 45% coverage, no annotations and no output schema, the description should do more. It covers the output payload well enough that an agent knows what it gets back, but it leaves the majority of styling parameters unexplained and omits persistence/side-effect behavior entirely.

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 45% across 11 parameters, so the description needs to compensate. It adds real meaning for primary (brand colour as hex), base (noodle drives shape/depth/motion, default mian) and accent (omit to derive via harmony), but font, heading, radius, weight, density and harmony mode are left entirely to the bare schema enums.

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 transformation: brand colour + noodle base in, a stylesheet (light/dark tokens on [data-brand]), usage notes and a contrast report out. That is far more concrete than a name restatement. It partially differentiates from siblings by pointing at find_noodles for choosing the base, but doesn't contrast with get_noodle_css or get_noodle, which sound adjacent.

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

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

"Use it whenever the user has brand colours" is a usable trigger condition and it names find_noodles as the prerequisite for picking a base. There is no when-not guidance and no routing away from the near-named siblings (get_noodle, get_noodle_css), so usage is implied rather than fully specified.

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 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 carries the full burden of behavioral disclosure. It says what the notes contain but does not state that this is a read-only retrieval of text, whether permissions are required, or what the response format looks like; for a no-annotation tool this is a clear gap.

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 short sentence with no wasted words, so length is appropriate. However, it is a dependent noun phrase rather than a clear front-loaded statement of purpose, which makes it less useful than a well-structured sentence would be.

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 a single enum parameter whose values are undocumented, the description is far too thin. It should at minimum clarify that it returns accessibility documentation for the specified component and indicate any constraints or usage context.

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 the single required id parameter, which contains a very large enum of component identifiers. The description refers to 'the component' but adds no meaning about the identifier format or that it must be one of the enumerated component names, so it fails to compensate for the schema's lack of parameter documentation.

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 phrase that hints at the content of the notes ('what the component guarantees and what the page author must do'), but it never states a retrieval verb or says these are accessibility notes. Combined with the name and title the purpose is inferable, but the description alone is vague and does not distinguish this from sibling tools like get_component or get_design_guide.

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 call this tool versus alternatives such as get_component or get_design_guide. The only implied use is when accessibility information for a component is needed, but that is left 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?

No annotations are provided, so the description carries the full burden, and it does disclose the three kinds of content returned, which is genuine behavioral context. However, it says nothing about format, size, authentication, or whether the result is a document versus structured data. Adequate disclosure of payload shape, silent on everything else.

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 fragment sentence, front-loaded with the payload contents and no wasted words. It is appropriately sized for a one-parameter read tool, though the missing verb makes it read as a label rather than a directive.

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 define the return. Listing classes, accessibility notes, and example HTML does most of that work, but it leaves the form (Markdown? JSON? code blocks?) and relative tradeoffs against sibling tools unspecified. Minimum viable for a simple lookup.

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, and it does not go beyond saying 'one component'. The single id parameter is fully enumerated in the schema with ~130 valid values, which makes the value space self-evident even without prose, so the practical gap is small.

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 the resource (one component) and enumerates the payload contents: classes, accessibility notes, and example HTML. This meaningfully distinguishes it from get_component_source, get_accessibility_notes, and get_example, since it is the aggregate view, though the description never says so explicitly. The retrieval verb is implicit in the name 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?

There is no statement of when to use this aggregate tool versus the narrower siblings (get_component_source, get_accessibility_notes, get_example) that clearly overlap in scope. The agent must infer that this is the 'everything at once' option from the content list alone. 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?

No annotations are supplied, so the description carries the full disclosure burden. It does add one genuinely useful behavioral fact — JS is only returned 'if it has behaviour' — which tells the agent output shape varies by component. It says nothing about permissions, error behavior, or whether the code is raw or transformed, 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?

A single efficient sentence with no filler, which is good, but it is under-specified rather than concise, and it contains a typo ('mian.js') that could confuse an agent looking for a real filename. The conditional clause is awkwardly placed after the main assertion.

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?

A two-parameter tool with no annotations, no output schema, and 0% schema coverage should explain its return shape and the role of each parameter. The description covers only one of the two parameters and omits any statement of what the response actually looks like (file contents, code blocks, concatenated output).

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 both parameters. It never mentions the 'part' parameter (enum css/js/both) at all, even though its wording implies a fixed combined response — leaving the agent to discover the selector from the schema alone. The 'id' parameter's meaning is only implied by the phrase 'the 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 names the resource ('the CSS for the component') and the conditional JS payload, so an agent can infer this retrieves source code for a component. However, it never states the verb (get/retrieve) and gives no differentiation from close siblings like get_noodle_css, get_component, or get_noodle, leaving ambiguity about which fetch 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 statement of when to use this tool versus alternatives, and the sibling list contains several overlapping retrieval tools (get_component, get_noodle_css, get_example). No prerequisites, no exclusion conditions, no routing guidance is provided.

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 reads as a static reference lookup, but it never says whether output is prose, structured rules, or token lists, how large the response is, or whether anything is stateful. Read-only behavior is only implied by the noun-heavy phrasing.

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 that front-loads the topic list and follows with the sub-topic detail; there is no filler. It is slightly crammed, but every clause carries content.

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 content lookup with no output schema, the description tells an agent what subject matter comes back by topic, which is adequate. It stops short of describing the form of the returned guidance, leaving a gap for a tool whose whole value is the content it returns.

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 0%, but the single parameter is an enum of five self-describing values, which the description expands by listing sub-topics (hue meanings and risks, palette roles, typeface classes, brand personality, logo principles, motion purposes and tokens). The value-to-topic mapping is only positional, so it adds moderate rather than decisive meaning.

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 enumerates the topical content covered (colour, type, branding, logo, motion), which maps cleanly to the enum, but it never states the action — that this returns reference guidance for a requested topic. It also gives no differentiation from nearby siblings like get_design_language, get_accessibility_notes, or get_site_guide, which an agent could easily confuse it with.

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 or when-not-to-use guidance, no mention of alternatives, and no indication of what an agent should reach for instead when it wants design-language tokens versus conceptual guidance. Usage is only implied by the topic list.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a static retrieval but never states that the call is read-only, whether results are cached, how large the payload is, or what the CSS recipe contains. Listing return contents is not the same as disclosing 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?

A single sentence with no filler; the content inventory comes first and the usage directive trails it. It is dense but every clause maps to something the tool returns, so little 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?

With no output schema and no annotations, the description does useful work by enumerating the returned sections, which helps the agent judge relevance. It remains silent on the required 'id' argument and on how this differs from the other noodle-related getters, so completeness is only partial.

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 0% and there is one required parameter. The phrase 'of one noodle' loosely implies that 'id' selects a noodle, but the description never mentions the parameter, its 67-value enum, or what an invalid id does. With a single undocumented parameter the schema alone must carry it, which it does not.

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 precisely (the design language of one noodle) and enumerates its contents: philosophy, principles, shape/surface/colour/type/motion/data rules, extension rules, and a CSS recipe. The title supplies the verb ('Get'), so the operation is legible. It does not, however, differentiate itself from siblings such as get_noodle_css or get_design_guide, whose scopes could plausibly overlap.

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?

One embedded clause gives a use case: 'use it to design components MIAN does not ship in exactly that style.' That is a real when-to-use hint. But no alternatives are named and no conditions for choosing this over get_design_guide or get_noodle_css are given, leaving the routing decision 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?

No annotations are provided, so the description carries the full behavioral burden. It does disclose the return shape ('a complete HTML page') and that it is parameterized by noodle/mode, which is genuinely useful, but says nothing about read-only nature, auth, size, or whether the output is a file vs. inline string.

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 terse sentences with the output description front-loaded and the action trailing. No filler, though the opening noun phrase is a fragment rather than a complete statement.

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 4-parameter, three-large-enum tool with no annotations and no output schema, the description covers the essentials (what it returns, that it is parameterized) but is thin on domain vocabulary and usage routing. Adequate but leaves 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 only 25% (just the 'example' index is documented), so the description must compensate. It names 'component', 'noodle', and 'mode' implicitly, but never explains what a 'noodle' is despite a 65-value enum, nor what mode changes, leaving the most opaque domain concept undefined.

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 complete HTML page showing the component') and the two axes that parameterize it (noodle and mode), so an agent knows it returns a full runnable page rather than a snippet. It does not explicitly contrast with close siblings like get_component or get_component_source, so the distinction 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?

'Save and open it' gives a concrete post-call action, which is a mild usage cue. However, there is no statement of when to prefer this over get_component, get_component_source, or get_template, and no exclusions or prerequisites, so guidance is only implied.

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 return content scope ('every token... light and dark, plus its design principles'), which is genuinely useful, but says nothing about permissions, output size, or whether the data is static/cached.

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 zero filler, and the content scope is front-loaded. It is efficient, though its brevity contributes to the surrounding informational gaps rather than being a structural flaw.

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 an opaque enum identifier, no output schema, and no annotations, the description should explain what the id values are and what shape the tokens return. It supplies only a content summary, leaving the caller unable to confidently pick an id or anticipate the response.

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 parameter is an opaque 66-value enum (mian, yangchun, linguine...). The description adds no meaning about what these values represent or that they are design-system names, so the agent has no help interpreting the required id.

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 content (all tokens of a design system, light and dark, plus design principles) but never states a clear verb or what a 'noodle' actually is, leaving the agent to infer that it fetches a theme/design system by id. It partially differentiates from get_noodle_css and get_design_guide by scope, but the core object remains vaguely defined.

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 prerequisites, and no mention of alternatives such as get_noodle_css (for CSS), list_noodles, or get_design_guide despite the crowded sibling set. The agent must guess whether this is the right tool for retrieving a design system.

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 return format ('as a CSS block'), which is meaningful for this tool. It does not state that the operation is read-only, what happens for an unknown id, whether tokens cover all themes, or any auth requirements, so key behavioral detail is missing.

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 tightly written sentence that front-loads the action and resource, with no filler. It is efficient, though arguably under-specified for the behavioral gaps it leaves open.

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 one-parameter getter with no output schema, the description does cover what is returned (a CSS block). It nonetheless leaves the parameter meaning, error behavior, and read-only nature unaddressed, which matters more given the absence of annotations and output schema.

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

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

Schema description coverage is 0% and the description adds nothing about the single required 'id' parameter. The enum in the schema is highly self-documenting (it enumerates noodle names), which partially compensates, but the description itself contributes no parameter meaning.

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

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

States a specific verb and resource (get one noodle's tokens) and specifies the output form (CSS block), which distinguishes it from the plain get_noodle sibling. It stops short of naming get_noodle explicitly as the alternative for non-CSS data.

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

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

The phrase 'to vendor or customise' implies the use case, giving an agent a reasonable signal of intent. However, it never states when to prefer this over get_noodle or list_noodles, so the routing guidance is only implied.

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 full behavioral burden, yet it says nothing about whether this is a read-only lookup, what form the result takes (instructions text, code snippets, templates), whether the 'noodle' selector affects output, or any auth/rate constraints. Only the stack scoping concept is implied.

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 filler and the scope qualification placed at the end. It is economical, though the extreme brevity leaves the definition under-specified rather than deliberately 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?

For a tool with no annotations, no output schema, zero schema description coverage, and a large opaque enum parameter, the description does not do enough. It fails to explain what the returned setup material looks like or what the noodle parameter changes, leaving real gaps an agent needs.

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 description only gestures at the required 'stack' parameter via 'in a given stack' without explaining the enum values. The second parameter, 'noodle', has a ~60-value enum and is completely unmentioned, so the agent gets no help understanding what it selects or whether it is optional.

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 action and resource: retrieve installation/setup instructions for adding MIAN to a project, scoped to a stack. It is clear enough to distinguish from data-returning siblings like get_component or list_templates, though it never explicitly names or contrasts 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 explicit when-to-use guidance, no prerequisites, and no mention of alternatives such as get_component, get_design_guide, or get_example that a developer might also consult during setup. The agent must infer intent entirely from the one-line purpose.

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

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

No annotations are provided, so the description carries the burden, and it does disclose the scope of content returned and that the two filter params narrow the result. However, it does not state that this is a read-only retrieval operation or describe the response shape, so the behavioral picture is only 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?

Front-loaded with the purpose in the first clause, followed by an informative content inventory. The long list of covered topics is justified because it tells the agent what content is retrievable, and there is little wasted text.

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 only three optional parameters, the description adequately covers what the tool returns and how to narrow it. The remaining gap — how this guide relates to the other guide-style siblings — is a differentiation issue rather than a missing detail for calling the tool correctly.

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

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

Schema coverage is only 33%: 'brief' is documented in the schema itself, while 'noodle' and 'page_type' are bare enums. The description partially compensates by explaining that these two params narrow the guide, but it never explains how a given page_type or noodle value changes the content returned.

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+resource: it returns a website-design guide covering process, principles, page anatomies, noodle-family composition and a launch checklist. It is more specific than a bare 'guide' but never distinguishes itself from close siblings like get_design_guide or get_design_language, leaving the agent to infer which guide to open.

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: 'Narrow it with page_type and noodle' tells the agent how to filter, but there is no statement of when this guide is the right choice versus get_design_guide/get_design_language/get_accessibility_notes, 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 does disclose the returned content (design notes and complete HTML) and the page/all-pages scope, but it omits operational traits such as read-only nature, permissions, response size, or pagination, leaving meaningful 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 short and front-loads the main output (design notes and complete HTML) before adding scope and mode details. The second sentence is an imperative rather than invocation guidance, but it is concise and does not bloat the definition.

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 4-parameter retrieval tool with no annotations, no output schema, and low schema coverage, the description is too thin. It does not explain the required template id, the effect of mode, the meaning of noodle, or how multiple pages are returned, leaving an agent with important unanswered questions.

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%, and the description does little to compensate. It mentions page selection and all-pages behavior, which duplicates the schema's page description, but it does not explain the required 'id' parameter or clarify what 'noodle' and 'mode' enum values mean beyond being selectable variants.

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 retrieval: a template's design notes and the complete HTML of one page or all pages. It is clear enough to distinguish from tools like list_templates or get_component, but it does not explain the domain-specific 'noodle' and 'mode' terms or differentiate itself from siblings such as get_design_guide or get_noodle.

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 explicit when-to-use guidance, no when-not-to-use guidance, and no named alternatives among the many sibling tools. The closing instruction 'Save each page as .html' implies a post-retrieval action but does not help an agent decide when this tool is the right choice.

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 real behavioral facts: only one page is read, its stylesheets are pulled in, and the required url must be a public http(s) address. It says nothing about fetch failures, blocked/non-public pages, latency, or rate limits, so the safety and error profile remains unknown.

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

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

Two sentences, front-loaded with the action and scope, with the usage trigger placed last. The middle list of return artifacts is long but every item is load-bearing because there is no output schema to carry it.

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 correctly compensates by describing what comes back and when to reach for it, which is the right content for an inspect/analyse tool. It stops short of covering failure modes for unreachable or non-public URLs, which is the remaining 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?

Only one parameter exists and the schema already documents it at 100% coverage ('A public http(s) address.'). The description reinforces the public/one-page constraint but adds no syntax, format, or validation meaning beyond the schema, 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?

The description uses a specific verb and resource ('Read one public web page and its stylesheets') and enumerates the concrete artifacts returned: a design-language score across five dimensions, findings, palette, fonts, corner shape, and closest MIAN noodles. That scope distinguishes it in practice from get_design_language or get_site_guide, but no sibling is named, so the differentiation is implicit rather than explicit.

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

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

It gives a clear triggering context: 'Use it when the user has an existing site to match or improve.' That is enough to route an agent correctly for this scenario, though no when-not condition or named alternative (e.g. plan_site for a greenfield build) is supplied.

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?

With no annotations, the description carries the full behavioral burden. It does disclose the output characteristic — up to four matches, each with an explanation — which is real value given there is no output schema. However, it says nothing about whether the call is read-only (it clearly is, but that is left to inference), what happens if both parameters are omitted, or any cost/latency considerations.

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 no filler, and the key scoping information (what drives the recommendation) is front-loaded. The phrase "from a brief in words" is slightly awkward but does not cost the agent comprehension.

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, zero-required read tool with no output schema, the description covers inputs, optionality in practice, and the shape of the result, which is most of what an agent needs. It stops short of explaining behavior when neither input is given and does not clarify how conflicts between brief and URL are resolved.

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 documented in the schema, establishing a baseline of 3. The description's added value is framing the two as alternatives or combinable ("or both") and echoing the format expectations ("calm editorial, serif"), but it adds no syntax, precedence, or conflict-handling rules beyond that.

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 (a design language / "noodle") and the basis on which one is chosen (a written brief, a site URL, or both), and mentions the return shape (up to four noodles with reasons). The verb "recommend" comes from the name/title rather than the description, but the operation is unambiguous and distinguishable from siblings like list_noodles and 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?

It implicitly tells the agent that a brief, a URL, or both may be supplied, which is useful context, but it never states when this tool is preferable to find_noodles, list_noodles, or get_noodle. No prerequisites, no exclusions, no explicit alternative routing.

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

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

No annotations are 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.