Cronus UI

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

Annotations already declare readOnlyHint=true and openWorldHint=false, establishing the safe read-only nature. The description adds behavioral context by listing the exact data fetched (source files, dependencies, registryDependencies, install command), which helps the agent anticipate the response. It does not contradict annotations and enriches beyond them, though it stops short of mentioning any edge cases or error 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?

The description is a single, front-loaded sentence that states the primary purpose and then lists the included details. It is dense but efficient, with no filler. It might be slightly long due to enumeration, but every clause adds value and the structure is clear.

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

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

For a single-parameter tool with no output schema, the description sufficiently explains what the tool returns and the scope (components and blocks). It covers the essential call details, so an agent can invoke it correctly without additional information. No critical gaps are apparent, though it could perhaps mention the exact format or any limitations.

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 schema has 100% description coverage and the parameter 'name' already includes examples ('button', 'data-table', 'pricing'). The tool description adds no additional semantic nuance about the parameter, so it does not exceed the baseline of 3 set by the schema-driven coverage.

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 ('Fetch') and resource ('full detail for a single Cronus UI component or block by name'), then enumerates exactly what is returned (source files, dependencies, registryDependencies, install command). It also explicitly states it works for both components and blocks, which distinguishes it from siblings that list or search items without fetching full details.

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 clearly: when you need full detail for a single named component or block. It states the tool covers both types, which provides context for selection. However, it does not explicitly mention when not to use it or point to alternatives (e.g., get_install_command), so it lacks explicit routing but still gives a clear context.

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

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

Annotations already declare readOnlyHint=true, and the description confirms 'Does not modify the project.' It adds value by describing the file's content (design rules) and the two output formats (compact vs. extended), which is useful behavioral context beyond the annotations. No contradictions.

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

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

The description is two sentences, front-loaded with the core action and resource, followed by usage context and a safety note. Every sentence earns its place with no fluff, and the structure is scannable.

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

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

For a read-only tool with three simple parameters, no output schema, and annotations covering safety, the description fully covers when to use it, what it returns, and the format distinctions. No missing information an agent would need to invoke it 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?

The input schema already provides 100% coverage with descriptions for all three parameters. The description adds a small clarification for the 'format' parameter (compact fits a system prompt, extended is the repo file), which helps but does not significantly enhance the schema-provided semantics. Baseline 3 applies given high schema coverage.

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 ('Return'), a precise resource ('the Cronus UI visual taste file (DESIGN.md)'), and the key parameter space ('for a theme × look'). It clearly distinguishes itself from sibling tools by focusing on design context rather than components, install commands, or catalog entries.

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 explicitly instructs to use this tool 'before generating UI' and lists the design rules it enforces (Aurora/Neutral dual identity, one primary CTA, hairline elevation, look rules). It does not mention when not to use it or alternative tools, but the usage context is unambiguous for an agent generating UI.

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?

The readOnlyHint annotation already signals a safe, non-destructive operation. The description adds value by explicitly stating that the tool 'only returns the command string' and that the CLI resolves registry dependencies automatically. This is transparent about the tool's side-effect-free behavior, though it does not detail command formatting or error scenarios.

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 compact and information-dense, with no filler. It front-loads the command-building purpose, adds the dependency-resolution behavior, and closes with the crucial 'only returns the command string' distinction and pointer to install_component.

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

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

For a one-parameter, read-only tool with no output schema, the description covers everything needed to call it correctly: what it builds, the input, the output nature, and the alternative for actual installation. The sibling tools are broad, but this description routes correctly by explicitly contrasting with install_component.

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 names parameter already includes a clear description and example ('['button', 'card', 'dialog']'). The description only restates 'one or more components/blocks' without adding new constraints or format details, so it does not need to compensate for the schema.

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

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

The description states a specific verb ('Build'), a specific resource ('npx cronus-ui add ...' command), and the scope ('one or more components/blocks'). It also explicitly distinguishes itself from installing by saying it only returns the command string, which separates it from install_component and the lookup/list sibling 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 description gives clear usage guidance: use this tool to build the command string, and use install_component when you actually want to perform the installation. This names the relevant alternative and the condition that selects it, leaving no ambiguity about when to invoke this tool.

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?

The readOnlyHint annotation already signals a safe read operation概, and the description adds transparency by specifying exactly what will be returned: each block's name, title, dependencies, and the `npx cronus-ui add <name>` install command. No hidden destructive or mutating behavior is suggested.

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 core purpose ('List the installable Cronus UI blocks'), then immediately adds precision with the registry type and examples, followed by the return contents. It is compact, informative, and free of filler.

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

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

For a zero-parameter read-only list operation, the description covers what is listed, what category it belongs to, what kind of items are included, and what fields the response contains. There is no pagination or edge-case note, but those are not essential for this simple catalog query.

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 no parametersuse, and schema coverage is 100%, so there are no parameter semantics to document. The baseline for a zero-parameter tool is 4; the description adds relevant output meaning without needing parameter detail.

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

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

The description states a specific verb and resource ('List the installable Cronus UI blocks'), defines the registry item type, gives concrete examples (hero, pricing, login, dashboard), and distinguishes blocks from components via 'larger, composed sections'. This differentiates it from sibling tools like list_components.

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 intended use is clear: call this tool to enumerate installable blocks and get their install commands. It does not explicitly say when to prefer a sibling tool, but the narrow scope and installation focus provide enough contextual guidance for an 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?

Annotations already declare readOnlyHint=true and openWorldHint=false. The description adds useful behavioral context: responses are compact cards, no source files, cheap on tokensتری. It doesn't contradict annotations.

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

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

Three short sentences: what it returns, cost characteristics, and pointer to the alternative. Every sentence earns its place.

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

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

For a compact read-only listing tool, the description states return fields, the optional filter, and when to prefer match_catalog. Nothing needed to invoke it correctly is missing.

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

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

Schema coverage is 100% for the single `kind` param; the description only says 'Filter with `kind`' without adding meaning beyond the enum already provided.

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

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

The description states a specific verb and resource: 'Return compact Hydra-ready cards for every component, block, variant, and template.' It also lists the exact fields returned)Skip. It distinguishes itself from match_catalog and the sibling list tools by describing scope.

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 says to use `kind` to filter and explicitly routes to `match_catalog` when picking the best item for a prompt. It doesn't fully spell out when to prefer this over the other list_* siblings, but the scope ('every...') and the match_catalog exclusion are clear enough.

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?

Annotations already carry readOnlyHint=true and closed-world hint, so the safety profile is covered and the bar is lower. The description adds genuine value beyond those annotations by disclosing the per-item return shape (name, title, npm/registry dependencies, install command), which matters since there is no output schema. No contradiction with annotations.

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 with zero filler: the scope/verb are front-loaded, and the second sentence delivers targeted return-field details. Every clause earns its place.

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

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

For a zero-parameter, read-only list tool with no output schema, the description covers the essential return fields per item. A brief pointer to sibling tools (e.g., get_install_command or search_registry) would fully complete routing, but nothing needed to invoke this tool correctly is missing.

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

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

The tool has zero parameters and the schema is an empty object with 100% coverage, so there is nothing for the description to explain. Baseline 4 for a no-parameter tool applies; the description correctly confirms this is an unfiltered, overall list.

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

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

States a specific verb and resource: 'List the installable Cronus UI components', narrowed by a precise type qualifier ('registry:ui'). The type constraint distinguishes it from sibling list tools like list_catalog and list_blocks, so an agent can tell what this enumerates without opening other schemas.

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 word 'installable' implies this is the discovery entry point for components one can add, but the description never names sibling alternatives (search_registry, get_component, get_install_command) or states when not to use it. Usage context is implied, not explicit.

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?

Annotations already mark this as read-only, so the description's main job is to disclose behavior beyond safety. It does that by specifying the return shape (`pick`, `intent` hits, `motion` hits, ranked `matches`) and the payload contents of cards. It does not discuss edge cases like empty results or ranking details, but these are not critical given the read-only annotation.

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 compact: three sentences front-load the purpose, then cover input, output, and routing. The phrase 'Two-query catalog match' is slightly jargon-heavy and unexplained, which costs it a 5, but every sentence otherwise earns its place.

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

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

With no output schema, the description compensates well by spelling out the return fields and card contents. Parameters like `kind` and `limit` are left to the schema, which is acceptable, though a note about what `pick` means in more detail or empty-result behavior would make it fully complete.

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

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

Schema description coverage is 100%, so the schema already carries the burden of documenting all 7 parameters, including the inference behavior for intent and motion. The main description adds the 'and/or structured filters' framing and an example query, but this is marginal value rather than necessary compensation.

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 action and resource: 'catalog match' against Cronus UI catalog tags, with both free-text and structured-filter inputs. It differentiates itself from siblings by explicitly saying cards do not carry source and directing source retrieval to 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 gives clear when-to-use context ('low-context agents', free-text and/or structured filters) and an explicit when-not: 'Cards carry description... not source.' It names the alternative action ('Fetch source with get_component only after picking a name'), so an agent knows exactly how to route after matching.

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?

The description adds meaningful behavioral detail beyond the readOnlyHint annotation: fuzzy/case-insensitive substring matching on names. It also frames the result as selecting an item for a follow-up fetch. No contradiction with annotations.

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 concise sentences: the first defines behavior, the second gives the intended workflow. Every phrase contributes; no filler.

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

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

For a one-parameter read-only search tool, the description covers what is searched, how matching works, and how it fits into the workflow. It does not detail the result shape, but the absence of an output schema makes a brief note slightly useful, not critical.

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

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

Schema coverage is 100% and the query parameter description already explains it matches against component and block names. The description reinforces this without adding significant new semantics.

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

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

The description clearly identifies a specific action (fuzzy-search) and resource (Cronus UI registry components and blocks), and specifies that matching is by name. It relates the tool to get_component, but it does not explicitly distinguish itself from sibling list tools like list_components or list_blocks, relying partly on the tool name.

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 concrete guidance: use this to find the right item before fetching its source with get_component. However, it does not clarify when to choose this over list_components/list_blocks or match_catalog, leaving some sibling differentiation implicit.

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