海棠诗社

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

Annotations already declare the tool as read-only, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds useful behavioral context by noting the tool reads public authors, returns a page of works, and returns 'author: null' when the author 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?

The description is two concise sentences. It front-loads the main purpose and then adds the key edge-case return behavior with no wasted words.

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 tool with rich annotations, complete parameter schema coverage, and no output schema, the description covers the core purpose, parameter expectations, and missing-author behavior. It does not describe the shape of the returned author object or works list, but the tool is still adequately specified for correct invocation.

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 the 'id' and 'page' parameters are already documented in detail. The description reinforces that the ID is numeric and that 'page' pertains to a page of works, but adds little semantic detail beyond the schema baseline.

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

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

The description states a specific verb and resource: 'Read a public author by numeric ID and a page of their works.' It clearly distinguishes get_author from siblings like get_work and list_authors by naming the author resource and its associated works page.

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 'by numeric ID' implies the tool is used when an ID is already known, and the schema notes the ID comes from a search or list result. However, the description does not explicitly state when to use this tool versus alternatives such as list_authors or get_work.

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 cover read-only, idempotent, non-destructive, and closed-world behavior. The description adds useful context beyond that: it says the work is public, lists the returned sections, and specifies that a missing work returns work: null.

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 the primary action front-loaded and the missing-work behavior stated immediately after. 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 simple read-by-ID tool with full schema coverage and safety annotations, the description provides enough: it identifies the resource, enumerates the returned content, and handles the null case. No output schema is needed because the return shape is described.

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 id parameter is already documented as a positive numeric ID from a search or list result. The description repeats the numeric-ID concept but adds no further syntax or format detail beyond 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?

It states a specific verb and resource: read a public work, by numeric ID. The description also enumerates returned content, making it clearly distinct from list_works and search_poetry.

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

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

Usage is implied by 'numeric ID' and the schema note that the ID comes from a search or list result, but the description does not explicitly say when to use this versus search_poetry or list_works. No exclusions or alternative routing guidance is 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?

The annotations already declare this a safe, read-only, idempotent, closed-world operation. The description adds that only public authors are returned and mentions URLs and page metadata, but it does not cover pagination behavior or result ordering beyond what the schema already states.

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 the core action and return shape front-loaded. Nothing is redundant or padded.

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 filtered-list tool with no output schema, the description supplies the essential return shape (URLs and page metadata) and the filtering behavior. Pagination limits and ordering are left to the schema, which is acceptable but keeps it just short of 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%, and the schema already documents page bounds and that category is a dynasty name from list_dynasties, not a group name. The description adds only that the dynasty filter is optional, which is already implied by the absence of required parameters, so a baseline 3 is appropriate.

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: browse public authors, with an optional dynasty filter, and notes that it returns URLs and page metadata. It is clearly distinct from get_author, though the description does not explicitly name that sibling as the single-author alternative.

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

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

Conveys that the dynasty filter is optional and that results are public authors, implying usage for browsing rather than fetching a specific author. It offers no explicit when-to-use or when-not guidance and does not name get_author or search_poetry as alternatives.

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, idempotentHint, destructiveHint=false and closed-world scope, so the safety profile is covered. The description adds that only public entries are listed and that name, slug and categories are returned, which is useful context. It says nothing about ordering, pagination or volume, but those gaps are modest given no parameters exist.

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 redundant clauses; every element (visibility scope, resource, returned fields) 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 listing tool with no output schema, the description covers purpose, scope and return fields, which is close to sufficient. It could note ordering or whether the result is a flat list, but nothing required for correct invocation 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 takes zero parameters, so the schema baseline is 4. The description's mention of name, slug and categories describes the return shape rather than parameters, which is harmless but not a substitute for parameter documentation that isn't needed here.

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 ('List') and a specific resource ('the public 词牌 taxonomy group') plus the fields returned. It distinguishes the resource from siblings like list_themes or list_types by name, though it doesn't say how it relates to them.

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 siblings such as list_themes or list_types, and no mention of preconditions. The only usage hint is the word 'public', which implies a scope but not a decision rule.

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 read-only, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely new behavior: it is public-scoped only, and passing browse filters returns live facets while the static list 'stays complete' — a non-obvious side effect an agent would otherwise not predict.

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 core action and return shape, with no filler. The facet sentence is densely compressed ('Optional browse filters also return live facets') and reads slightly ambiguously about what the filters affect.

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

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

No output schema exists, yet the description discloses the return shape (name/slug pairs) and the facet behavior, which is what an agent needs to invoke and interpret it. For a zero-required-parameter listing tool with full annotation coverage, only the filter semantics remain slightly under-explained.

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

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

Schema coverage is 100%, so the baseline is 3; the description earns above that by explaining what the optional filters actually do — they trigger live facet computation for collections, dynasties and types rather than narrowing the returned list. It does not restate per-parameter formats, which the schema already handles.

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 all public collections') plus the return shape ('name/slug pairs'), which an agent can distinguish from list_dynasties, list_types or list_groups by resource name alone. It does not explicitly contrast itself with the nearest sibling (list_groups), so it stops short of a 5.

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

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

Gives a concrete downstream usage rule: take the collection slug and use it as the collection ID string when browsing works. That tells the agent when to reach for this tool, but it offers no exclusions or explicit alternative (e.g. when to prefer list_groups).

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 cover read-only, idempotent, non-destructive, and closed-world behavior. The description adds useful behavioral context by explaining that optional filters return live facets while the static dynasty list remains complete.

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 three compact sentences, front-loaded with the core purpose and return format. Every sentence adds useful information without redundant restatement of the name or annotations.

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 listing tool with no output schema, the description provides the key return shape and explains facet behavior with optional filters. Combined with the fully documented schema and annotations, an agent has enough information 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?

Schema description coverage is 100%, so the baseline would be 3 without additional context. The description adds meaningful semantics beyond the schema by clarifying that optional filters activate live facets but do not truncate the static dynasty 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?

The description specifies the exact verb and resource: list all public dynasties, returning name/slug pairs. It also clarifies the downstream use of dynasty names as category values, so an agent can distinguish this from sibling list/get 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?

It clearly states the primary usage context: use the returned dynasty name as category when browsing works or authors. It also explains what optional browse filters do, though it does not explicitly name alternatives 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false and destructiveHint=false, so safety is covered. The description still adds real value by disclosing that only *public* entries are returned and by naming the three returned fields — important since no output schema exists. It leaves out ordering and whether the category list is nested, which is a minor 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?

A single front-loaded sentence with the verb first and no filler. Every clause (public scope, resource, returned fields) carries information an agent needs.

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 no-parameter read tool with full annotation coverage, the description supplies what the annotations cannot: the scope filter (public) and the return shape. Only a gloss for the untranslated '节日' and a hint about result size/ordering would make it 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline is 4 by rule. The input schema is an empty object with additionalProperties=false, consistent with the description.

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?

A specific verb ('List') applied to a specific resource ('the public 节日 taxonomy group'), plus an enumeration of what comes back (name, slug, categories). It doesn't distinguish itself from the many sibling list_* taxonomy tools (list_themes, list_groups, list_types), so an agent must infer that each targets a different taxonomy vocabulary.

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: an agent can infer this is the lookup for the festivals vocabulary, presumably to resolve slugs/IDs before filtering works. There is no explicit statement of when to prefer it over list_themes or list_groups, nor any note about prerequisites or follow-up calls.

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 readOnly, idempotent, non-destructive and closed-world, so safety is covered. The description adds two things annotations do not: that only 'public' entries are returned (a visibility constraint) and which fields come back, which matters since there is no output schema.

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 its returned fields are stated together without 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?

For a zero-parameter list with no output schema, the description usefully names the returned fields (name, slug, categories). Minor gaps remain: whether the whole taxonomy is returned unpaged and whether categories are nested objects are not stated.

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

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

The tool takes zero parameters, so parameter semantics carry no risk and the baseline applies. The description correctly implies a full unfiltered enumeration with no paging or filter arguments.

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 ('List'), a specific resource ('the public 地理 taxonomy group'), and even the returned attributes (name, slug, categories), so an agent can tell it apart from list_themes, list_dynasties and other taxonomy siblings. It does not explicitly name a sibling, but the resource is narrow enough to be self-identifying.

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: it is the enumeration counterpart to the other list_* taxonomy tools, with no filters needed because there are no parameters. The description never says when to reach for this versus another taxonomy list or search_poetry, so an agent must infer selection from the resource name alone.

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 establish that this is a read-only, idempotent, non-destructive, closed-world operation. The description adds useful scope by naming the exact public groups and stating that categories are included, but it does not describe ordering, pagination, or return format beyond "with their categories."

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 filler beyond the necessary enumeration of group names. The ambiguous word "remaining" is the only minor structural weakness.

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 zero-parameter schema and rich annotations, the description is sufficient to invoke the tool and know what will be returned at a high level. It is less complete for selection because it does not explain how these groups relate to sibling taxonomy list tools or resolve the ambiguity of "remaining."

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

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

The tool takes zero parameters, so there are no parameter semantics for the description to clarify. Baseline for a zero-parameter tool is 4.

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 ("List") and a specific resource ("public taxonomy groups") and enumerates the exact groups returned, so the agent knows what the tool does. However, it does not distinguish these groups from the many sibling taxonomy tools such as list_themes, list_types, or list_sorts, and "remaining" lacks a clear referent.

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 does not state when to use this tool versus alternatives such as list_themes, list_types, or list_collections. The word "remaining" implies some context but does not clarify which groups have already been listed elsewhere or when an agent should choose 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?

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is fully covered. The description adds one genuine detail beyond that — the result is limited to the 'public' taxonomy group — but says nothing about ordering, or whether the group could be empty or localized.

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 scope ('public') comes before the payload description (name, slug, categories). Nothing could be cut without losing 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?

For a zero-argument read tool with rich annotations and no output schema, the description supplies the essential shape of the response (name, slug, categories) and the public-only scope. Only the absence of output structure detail keeps it from a 5, and that is minor at this complexity.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline applies. Schema coverage is 100% and the empty input schema is self-explanatory.

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 (list) and a specific resource (the 时令/seasons taxonomy group), and enumerates the returned fields (name, slug, categories). That is enough to distinguish it from sibling list_* taxonomy tools such as list_festivals or list_solar_terms, though the untranslated term 时令 slightly muddies what the group actually covers.

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

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

The description gives no when-to-use guidance and names no alternatives, even though a cluster of near-identical taxonomy listers exists (list_themes, list_cipai, list_festivals, list_solar_terms, list_dynasties). An agent must infer from the names alone why it would pick seasons over festivals.

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 read-only, idempotent, non-destructive behavior. The description adds 'public', indicating no authentication required, and specifies the returned fields (name, slug, categories), which is useful context beyond 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?

A single, front-loaded sentence with zero waste. Every word contributes to understanding the tool's output.

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 list tool with no parameters and rich annotations, the description adequately explains what is returned (name, slug, categories). It does not mention pagination or total count, but these are likely unnecessary for a small taxonomy list.

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, so the baseline is 4. The description does not need to explain parameter semantics, and no additional information is required.

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 (List) and resource (public 节气 taxonomy group), making it clear what the tool does. It does not explicitly differentiate from sibling list_* tools, but the resource name is distinctive enough for an agent to identify it.

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 usage by naming the resource, but provides no explicit when-to-use guidance or alternatives. An agent can infer it should be used when solar terms are needed, but no conditions 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?

Annotations already declare readOnly/idempotent/non-destructive, so the bar is lower. The description adds a genuinely useful behavioral nugget: a null slug means omit sort for the site default, which tells the agent how to interpret and act on a returned value.

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, no filler, with the resource described first and the edge case (null slug) directly after. Every clause carries information.

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

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

For a zero-param, no-output-schema list tool, the description covers what is returned and how to handle the degenerate value. The only small gap is the exact response shape (label/slug field names), which is left implicit.

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

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

The tool takes zero parameters, so the baseline is 4. Nothing in the description can mislead about inputs, and the note about null slugs applies to output values rather than parameters.

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?

Clear verb+resource: "List public work sort labels and slugs" tells the agent exactly what the tool returns. It doesn't explicitly name a sibling or state how it differs from list_works/list_types, but the resource (sort options) is distinctive enough on its own.

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 second sentence implies usage (the resulting slug is fed elsewhere, and null means omit sort), but the description never states when to call this versus alternatives or what operation consumes the slugs. Usage must be inferred from the domain.

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, idempotentHint, non-destructive, and closed-world, so the safety profile is covered. The description adds the useful detail that only public themes are returned and enumerates the response fields, but says nothing about ordering, completeness, or nesting beyond the flat list.

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 padding. It is appropriately sized, though the untranslated '主题' alongside the English 'taxonomy group' reads slightly awkwardly.

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 listing with no output schema, the description supplies the essential return shape (name, slug, categories) and scoping ('public'). Nothing else is strictly required to invoke it correctly; only ordering/pagination semantics are absent, which are minor here.

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

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

The tool takes zero parameters and the schema has additionalProperties: false, so there is nothing to disambiguate; baseline 4 applies. The description correctly implies a no-filter, return-everything call.

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

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

Specific verb 'List' plus the resource 'public 主题 taxonomy group', and it names the returned fields (name, slug, categories). It implicitly separates itself from sibling taxonomies like list_dynasties or list_types by naming the theme group, though it never explicitly contrasts with them.

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 versus the many sibling list_* taxonomy tools, and no prerequisites or exclusions. An agent must infer usage from the name alone; the only hint is 'public', which suggests reference data rather than user-scoped content.

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 annotations already declare this a safe, idempotent, closed read. The description adds genuinely non-obvious behavior: passing browse filters does not narrow the static list, it only attaches live facets for collections, dynasties and types. That prevents an agent from misreading filtered calls as filtered results.

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, zero filler, and the core purpose (

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 full schema coverage, no output schema, and safe annotations, the burden is light and mostly met. The one remaining question — whether filters change which kinds are returned — is answered by the 'static list stays complete' clause.

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

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

Schema coverage is 100%, so the baseline is 3; the description earns above that by explaining the collective effect of the three optional filters — they enrich the response with live facets while the kind list stays complete. That is semantic meaning the enum and per-param docs do not convey.

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 all public work kinds as name/slug pairs', which tells the agent exactly what comes back. It does not name a contrastive sibling (e.g. list_collections, list_dynasties), but the resource is distinct enough to be inferred from the name/description pair.

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 the kind slug as tag when browsing works' guides downstream consumption rather than tool selection, so it only partially answers when to call this. The sentence about optional filters returning live facets implies usage context, but there is no explicit when-not or alternative-tool routing among the many list_* siblings.

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 readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds useful behavioral facts beyond that: it is scoped to PUBLIC works only and returns work URLs plus page metadata, which the annotations cannot convey.

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, zero waste, with the resource and filter surface front-loaded and the return value stated second. Nothing is repeated or padded.

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 5 optional params fully documented in the schema, complete annotations and no output schema, the description supplies the remaining pieces an agent needs: the public-only scope and the shape of the response. It only lacks an explicit routing hint toward search_poetry for keyword queries.

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

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

Schema coverage is 100%, so every parameter is already documented in detail (enums, ranges, examples, cross-references to list_types/list_dynasties/list_collections). The description only restates the filter list in shorthand ('collection ID, dynasty name (category), kind slug (tag)'), adding no syntax or format detail beyond the schema; baseline 3 applies.

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

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

States a specific verb (browse) and resource (public works) plus the optional filter dimensions, which distinguishes it from get_work/search_poetry by naming the enumeration use case. It does not explicitly contrast itself with search_poetry, so the differentiation is inferred rather than stated.

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

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

'Browse ... with optional ...' implies a filtered listing and the word 'optional' signals all filters are skippable, so usage is inferable. But there is no explicit when-to-use-this-vs-search_poetry guidance, no prerequisites, and no statement of what a keyword search should use instead.

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 context beyond the annotations by stating that results include public URLs and short excerpts. This tells the agent what kind of output to expect from a read-only search operation. It does not describe pagination or how workLimit and authorLimit affect result volume, but the annotations already establish safety and idempotency.

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 three short sentences with the main purpose front-loaded. The return behavior and the alternative tools are presented efficiently with 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 simple read-only search tool with no output schema, the description covers the core purpose, the nature of the result excerpts, and the detail alternatives. It is mostly complete, though it omits how the two result limits shape the response and whether results are paginated or capped.

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%, and the description does not explain workLimit or authorLimit at all. It only reinforces the meaning of the query parameter by saying the search is by keyword across authors and works. The two limit parameters remain undocumented in both the schema and the description, so this dimension does not 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?

The description states a specific verb and resource: search public classical Chinese poetry by keyword across authors and works. It distinguishes itself from detail-oriented siblings by directing users to get_work or get_author for details. It does not explicitly distinguish itself from list_works or list_authors, so it falls short of full sibling differentiation.

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

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

The description gives clear usage context by positioning this as a keyword search across authors and works. It names get_work and get_author as the alternatives for detailed lookups, which helps route the agent correctly. It does not specify when to prefer list_works or list_authors instead, but the core when-to-use guidance is present.

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