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

No annotations are present, so the description carries the full burden. It discloses that containers can hold children via parentPath, but does not mention side effects, validation rules, whether existing components are affected, permission requirements, or any reversible/irreversible nature. For a mutation tool with no annotation coverage, this is a significant 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 well-structured with bullet lists and a clear opening sentence, but it is somewhat long (~150 chars). Each line earns its place, listing categories and the parentPath concept, plus a pointer to a skill file. No redundancy, though it could be trimmed slightly 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 complex tool with 9 parameters and no output schema, the description covers the main action and component types but omits return values, error conditions, and prerequisites like authentication (though login/check_auth siblings exist). The pointer to a skill file for detailed props is helpful, but the description alone leaves gaps in what the result of adding a component looks like.

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%, setting a baseline of 3. However, the description adds genuine value by enumerating the valid values for the `type` parameter, which is a free-form string in the schema. This list (Input, Number, TextArea, etc.) saves agents from guessing or external lookups. Other parameters are not individually addressed, but the type enrichment is substantive.

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?

Opens with a specific verb and resource ('向当前表单添加一个组件'), and then enumerates the full component taxonomy (form, container, table, display), which cleanly differentiates it from siblings like remove_component, move_component, and copy_component. The mention of parentPath for nesting is distinctive to add operations.

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 its use case ('向当前表单添加一个组件') but does not explicitly state when to prefer this over alternatives like copy_component or move_component for duplicates/existing components. No exclusions or conditional routing are provided, so the guidance is implicit rather than 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'add' without explaining side effects, required permissions, reversibility, or impact on existing data. For a mutation tool, this is a critical 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, efficient sentence with no redundancy. Every word contributes to conveying the tool's purpose, making it appropriately concise and front-loaded.

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 description is minimal, offering no context about the tool's role in the form configuration system, its relationship to other detection-date tools, or expected outcomes. Given 5 parameters and no annotations, this is inadequate for an agent to fully understand the tool's 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?

The input schema covers 100% of parameters with descriptions, so the baseline is 3. The description does not add any extra meaning to the parameters beyond what the schema already provides, so it stays at 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 clearly states the action ('add') and resource ('detection date field binding') with the specific component types (DatePicker / DatePicker.RangePicker). It distinguishes itself from siblings like remove_detection_date_item and list_detection_date_items by denoting an add operation, though it does not explicitly name alternatives.

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

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

The description provides no guidance on when to use this tool versus alternatives such as set_detection_date or add_component. There is no mention of prerequisites, contexts, or exclusions, leaving the agent to infer usage from the 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?

With no annotations provided, the description must disclose behavior but fails to. It doesn't mention side effects, prerequisites, how it distinguishes add vs update (e.g., optional id), or any failure conditions. The pointer to the skill doc is useful but not behavioral disclosure.

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 concise (two short sentences) and front-loads the purpose. It includes a useful reference to the syntax skill without unnecessary verbosity. Could be slightly more structured but overall efficient.

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 has 5 parameters, no output schema, and no annotations. The description lacks crucial context: how to choose between add/update, the role of the optional 'id', and dependencies on template context. It defers syntax details to a skill but leaves behavioral and usage gaps unaddressed.

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 baseline is 3. The description adds marginal value by pointing to 'Skill: expression-engine.md' for expression syntax and noting 22 built-in functions, which helps with the 'expression' parameter. It does not elaborate on other parameters beyond 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 clearly states the action 'add or update calculation formula' with a specific verb and resource. However, it does not differentiate from sibling tool 'update_formula', which likely specializes in updates, creating potential confusion about scope 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?

No guidance is given on when to use this tool versus the sibling 'update_formula' or 'list_formulas'. The description doesn't explain decision criteria (e.g., whether to pass an ID for updates) or any exclusions.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It states the action but does not mention side effects, required state (e.g., FormGrid must already exist), or whether the operation modifies the template schema in a non-reversible way. Minimal transparency for a mutation tool.

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

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

The description is a single short sentence, which is front-loaded and concise in length. However, it is under-specified; it lacks essential details about parameters and usage. The brevity comes at the cost of usefulness, so it is not appropriately sized for the tool's complexity.

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 three parameters, no annotations, and no output schema, the description is severely incomplete. It provides no context about the FormGrid structure, column properties, or how gridPath/columnName are used. An agent cannot reliably invoke this tool correctly based on the provided information.

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 does not mention any of the three parameters (title, gridPath, columnName). The agent receives no guidance on what these parameters mean or how they relate to the FormGrid. The description fails to compensate for the schema 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 uses a specific verb (add) and names the resource (GridColumn child node to FormGrid), which clearly states the operation. It distinguishes from the broader add_component sibling by being more specific, though it doesn't explicitly name that sibling as an 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?

No guidance is provided on when to use this tool versus alternatives like add_component or set_property. The description does not mention prerequisites, context (e.g., FormGrid must exist), or exclusion cases, leaving the agent to infer usage from the 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?

No annotations are provided, so the description carries the full burden. It discloses that the operation mutates state ('add or update') and gives the name format, but it does not describe what happens on add versus update, whether existing values are overwritten, side effects, return values, or error conditions. Minimal disclosure for a mutation tool with zero annotation coverage.

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 concise sentence with the naming format front-loaded. It is efficient, but the concision comes at the cost of clarity given the add/update ambiguity with the sibling tool. The sentence is compact yet leaves important behavioral gaps unfilled.

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 mutation tool with no annotations, no output schema, and a naming scheme that depends on parameter formatting, the description is too thin. It fails to disambiguate add versus update against the update_output_item sibling, describe side effects or return values, or explain how the id parameter selects between the two behaviors.

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 all four parameters are already documented in the schema. The description adds value by explaining how the parameters combine into the naming convention (raw##{card title}-{field title}##{field name}) and hinting that id distinguishes add from update. Beyond that, it does not compensate for the id parameter's conditional role.

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 ('add or update output value') and includes the naming format. However, it is ambiguous: the tool is named add_output_item yet claims to 'update' as well, while a sibling update_output_item exists. This overlap muddies what exactly this tool is for versus its sibling.

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

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

No when-to-use or when-not-to-use guidance is given. There is no mention of alternatives such as update_output_item or remove_output_item, and no explanation of the circumstances that call for adding versus updating. The id parameter implicitly signals update behavior, but that is inferential, not stated.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the cell value updates automatically after binding, which is useful, but it omits other behavioral details such as whether existing bindings are overwritten, whether the operation is reversible, or any side effects on related fields. For a mutating operation, this is a significant 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, concise sentence that front-loads the core action and effect. There is no redundant wording, and it is appropriately brief for the tool's simplicity.

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 description mentions only binding to form fields, but the schema also supports binding to table loop data (bindType 'tableData'). This omission could mislead an agent into thinking the tool only handles form fields. Additionally, there is no mention of return values, error conditions, or behavior when a cell is already bound. Given the moderate complexity and lack of output schema, the description is incomplete.

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 all three parameters (cellKey, bindType, fieldPath) are documented in the schema. The description adds marginal context by describing the binding effect but does not elaborate on parameter formats or edge cases beyond what the schema provides. This meets the baseline for full 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 clearly states the action (bind table cell to form field) and the effect (cell value updates automatically). It uses a specific verb and resource. However, it does not explicitly differentiate from the sibling tool bind_cell_loop, though the schema enum distinguishes the bindType. It is clear enough to understand the primary purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives like bind_cell_loop or set_spreadsheet_cell. It does not mention prerequisites, situations where binding is appropriate, or any exclusions. The agent must infer usage from the schema alone, which is not sufficient for correct tool selection.

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 burden. It only says 'bind cell range to loop data' without disclosing side effects, required context, mutation behavior, or return values. This is severely inadequate for an agent to anticipate consequences.

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 concise sentence with the primary action front-loaded. However, it is under-specified and provides no structure for additional information. It is not overly verbose, but it fails to deliver necessary detail.

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 output schema, no annotations, and three parameters, this description is drastically incomplete. It does not explain what 'loop data' refers to, what constitutes a 'cell range', or what the expected outcome is. An agent would have to guess or introspect schema names.

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 covers 67% of parameters (arrayPath and columnField are described), but cellKey is undocumented. The description adds no parameter-level details beyond the schema. Since it doesn't compensate for the missing parameter, it falls below the 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 clearly states the action (bind) and the target (cell range to loop data such as ArrayTable). It is specific enough for an expert to grasp the primary function. However, it does not distinguish itself from the sibling bind_cell_data, leaving potential ambiguity.

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 alternatives. No mention of prerequisites, conditions, or exclusions. Sibling tools like bind_cell_data and set_spreadsheet_cell exist, but no differentiation 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool checks token validity, but does not disclose the return format (boolean, status object, or error), whether an invalid token throws or returns, or any side effects. With zero annotations and no output schema, this is a meaningful gap for an agent trying to interpret the result.

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. Every word contributes to the meaning, and the information is immediately front-loaded. This is appropriately sized for a zero-parameter utility.

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 validation tool this is mostly adequate, but the absence of any output-schema or annotation means the description should disclose what the checker returns. It does not. Given the low complexity, this is a minor-but-real omission rather than a severe one.

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 documents an empty object with 100% coverage. With 0 params, the baseline is 4 since there is nothing for the description to add beyond the schema — and it correctly implies the operation takes no input.

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 (检查/check) and resource (current token), and states the exact purpose: determining whether the token is still valid. This is not a tautology — it clearly differentiates from the sibling 'login' (which obtains a token rather than validates one), making the tool's role unambiguous.

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 invoke this tool versus the sibling 'login' tool, nor any mention of usage context such as calling it before other authenticated operations. The reader must infer that it is a pre-check step. No exclusions or alternatives are 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?

No annotations are provided, so the description carries the full disclosure burden. It only states the operation's intent but does not disclose whether the original is retained (implied by 'copy' but unstated), any validation, side effects on other components, permissions needed, or error behavior. It also does not mention whether parentPath must be within the same template or what happens if the new name conflicts.

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. It efficiently conveys the core action and the optional parameter, earning its place despite being minimal in depth.

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 mutation tool with no annotations, no output schema, and three arguments involving tree paths, the description is severely incomplete. It lacks any explanation of return value, error conditions, recursion behavior, uniqueness requirements, or the default parentPath. An agent cannot safely call this tool without external code inspection.

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%, so the description must compensate. It explains newName and parentPath but leaves sourcePath entirely implicit; '复制组件子树到新 name' implies the source but does not name the parameter. The description adds minimal value over the schema and fails to clarify path formats, defaults, or the relationship between sourcePath and parentPath.

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 (复制/copy) and resource (组件子树/component subtree) and the key result (new name, optional new parentPath). It distinguishes from move_component by using 'copy', but it does not define what a 'component subtree' is or clarify that the source is preserved. The purpose is understandable but underspecified.

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

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

No guidance on when to use this tool versus alternatives like move_component, add_component, or reorder_component. No mention of prerequisites, constraints (e.g., template context), or when not to use it. The agent must infer usage from the vague action description.

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 of behavioral disclosure. It indicates a mutation-like operation (copying creates a new template) but does not mention side effects, whether the source is modified, required permissions, or what happens after copying (e.g., returns the new ID). This is a significant gap for a copy operation.

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

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

The description is only one short sentence, but it is under-specified rather than efficiently concise. It lacks essential details and does not front-load parameters or outcomes. It is not a well-structured description for the tool's complexity.

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 copy operation with a required sourceTemplateId and an optional newName, and with no output schema, the description is severely incomplete. It does not explain the return value, the effect of the copy, or any constraints. An agent would not know how to call this 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 0%, so the description must compensate. It does not mention sourceTemplateId or newName at all. The agent has no understanding of what these parameters represent or how they affect the copy operation.

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 ('copy') and resource ('template'), and adds that it selects the new template. This distinguishes it from create_template (which likely creates from scratch) and delete_template, though it doesn't explicitly name alternatives. It is specific enough to understand the core function.

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

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

No guidance is provided on when to use this tool versus the many siblings (create_template, select_template, etc.). There is no mention of context, alternatives, or prerequisites. The agent is left to infer usage from the name and description.

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 full burden here. It discloses that the tool creates a token (implying a side effect — a new session is created), but gives no detail on authorization requirements, whether the token expires, HTTP failure modes, or the response shape. Barely above nothing for a state-changing operation.

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

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

A single, front-loaded sentence with the endpoint included — no wasted words. The HTTP method and path are useful operational context. It's appropriately short, though it leans toward under-specification rather than efficient completeness.

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

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

For a tool generating a token, the agent needs to know what the response contains and how parameters constrain it. With no output schema, no annotations, and 0% parameter coverage, the description leaves those gaps open. Incomplete 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 0% and the description adds zero meaning to the two parameters (versionId, templateId). An agent cannot tell which is required, how they relate, or what values are valid. The description does not compensate for the missing schema 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 states a clear verb-resource pair: POST /template-preview/session generates an external share preview token. The purpose is comprehensible and distinct from siblings — no other tool name mentions 'preview_session'. However, it doesn't articulate how it differs from the many template-related siblings in terms of 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?

No guidance is given on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., needing a logged-in session, existing template/version) or when creating a preview token is appropriate. An agent gets no directional help.

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?

Since no annotations are provided, the description carries the full burden. It discloses the creation action, the side effect of selecting the new template as current editing template, and the login requirement. However, it does not describe return values, potential overwrite or destructive behavior, or any other side effects.

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 short sentences that front-load the action and the prerequisite. There is zero fluff; every word earns its place. The structure is clean and easy to parse.

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

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

The description covers the core action and a prerequisite, but it lacks guidance on when to use this tool versus sibling tools (e.g., copy_template, save_template). It also doesn't mention what the tool returns or any post-creation steps. Given the 4-parameter complexity and no output schema, more contextual detail would be helpful.

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?

All 4 parameters have schema descriptions (100% coverage), so the baseline of 3 applies. The tool description itself adds no additional parameter information beyond the schema, which is acceptable given the high 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 clearly states the verb (create) and resource (new template), and specifies that it also selects the template as the current editing template. This distinguishes it from editing tools like save_template, but it does not explicitly name alternatives, so it falls short of a 5.

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

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

The description provides a clear prerequisite ('need to login first'), which is useful context. However, it does not explicitly state when to use this tool versus other template tools (e.g., copy_template or create_preview_session), nor does it mention any exclusions or alternative conditions.

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. The description only says 'delete', which implies destruction, but does not disclose whether the operation is irreversible, whether it requires specific permissions, what happens to dependent data, or what the response looks like. With zero behavioral context, an agent cannot predict the side effects.

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 very short, but this is under-specification rather than conciseness. It consists of a single phrase with no structure or additional context. There is no sentence that earns its place because there is essentially only one short clause, which does not satisfy the information needs of an agent.

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?

While the tool is simple (one parameter, no output schema), the description is insufficient for an agent to use it correctly in the broader context. It does not explain what 'row' refers to (e.g., row index in a table, in a spreadsheet, in a template), what the effect is on surrounding data, or how it relates to sibling tools. The minimalism leaves too much ambiguity 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?

The input schema provides only the parameter name 'row' with type 'number', and no description. The tool description says 'the specified row', which does add a slight hint that the number identifies which row to delete, but it is just a restatement of the parameter name. It does not explain the range, indexing (0-based vs 1-based), or any constraints. Schema coverage is 0%, so the description should compensate, but it barely does.

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

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

The description states a clear verb and resource: 'Delete the specified row.' It is not a tautology, but it is extremely generic. There is no mention of what kind of row or in what context (e.g., which table, template, or data structure), and it does not differentiate from siblings like 'insert_row' or other row-related tools. It is minimally clear but lacking specificity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, conditions, or exclusion criteria. An agent has no information about when this is the appropriate tool to invoke among the many siblings, so the usage guidance is essentially absent.

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 full responsibility for behavioral disclosure. The verb 'delete' conveys that the operation is destructive, but the description adds nothing beyond the tool name — it doesn't state that the action is irreversible, whether dependent data is affected, or if any confirmation is required. Significant gap for a destructive operation.

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

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

A single, front-loaded sentence with no wasted words. It is appropriately sized for a simple one-parameter tool, though it borders on under-specification rather than achieving true informational conciseness.

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 structurally simple (1 param, no output schema), lowering the bar, but the description omits the return/response behavior and any note about the irreversible consequences of deletion or dependencies on templates in use. For a destructive action this is a meaningful completeness gap.

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

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

Schema description coverage is 0% and the description does not clarify the templateId parameter — its meaning, its source (e.g., from list_templates or get_template_detail), or its format constraints. The parameter is partially self-evident from the tool name, but with zero schema coverage the description should compensate and 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 states a specific verb ('删除' = delete) and resource ('指定模板' = specified template). It distinguishes from siblings since it's the only tool in the list with a delete-based operation; siblings use create/copy/save/update verbs for the same resource. Clear purpose though minimal.

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

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

No guidance on when to use this tool vs alternatives, no preconditions (e.g., template must exist or not be in use), and no mention of related list/get operations that typically precede a deletion. For a destructive tool, the absence of selection conditions or exclusions leaves the agent to infer the context entirely.

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 only states what the tool returns, not whether it is read-only, has performance implications, or any side effects. For a simple getter this is minimal, but without annotation coverage, more transparency (e.g., 'This is a read-only operation' or 'Returns all categories and samples') would be expected. The description adds no behavior beyond the literal action.

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, compact sentence with no redundant words. It front-loads the core purpose and includes the key detail about hierarchy, earning a perfect score for conciseness.

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 getter with no parameters and no output schema, the description is functionally sufficient but lacks contextual richness. It doesn't mention whether the result is read-only (especially useful without annotations), nor does it clarify the exact shape of the tree (e.g., are samples embedded under categories?). The presence of many sibling tools makes a bit more contextual guidance valuable, so a 3 is appropriate.

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 description does not need to explain parameter semantics. The baseline for 0 params is 4, and the description does not introduce any confusion about inputs.

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

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

The description clearly states the tool gets the complete category tree structure and specifies the hierarchy (category → sample). It distinguishes itself from list_categories (which likely returns a flat list) by mentioning 'tree' and 'complete'. However, it doesn't explicitly name siblings or contrast with them, so it stops short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like list_categories or list_samples. It doesn't state situations where the full tree is needed, nor does it exclude cases where a flat list would suffice. Usage is implied by the name and description but not explicitly articulated.

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 states what is returned (formulas, output values, detection dates) but says nothing about the 'current session' context—what defines the session, whether data reflects live state or a snapshot, whether the call can fail under certain conditions, or the structure of the response. For an annotation-less getter, the description offers only the minimum behavioral surface.

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 zero filler. The verb and resource are front-loaded, and the parenthetical enumeration of contained elements adds value without excess. Ideal length for what is a simple no-parameter getter tool.

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, no-output-schema, no-annotation tool, the description is mostly adequate: it conveys the purpose and the data elements involved. However, it leaves undefined what 'current session' means and does not hint at the response shape, which an agent might need to interpret correctly. Given the tool's simplicity the gap is moderate, but the burden of full disclosure with no annotations means a 3 is appropriate.

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 schema description coverage is 100%, so the rubric baseline is 4. The description adds nothing about parameters because none exist to document. This score reflects the fact that the schema fully covers the parameter surface and no compensation is needed.

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 (

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

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

No guidance is provided on when to use this tool versus alternatives. With over 60 sibling tools including list_formulas, list_output_items, and list_detection_date_items that retrieve subsets of the same data, the description gives no indication that this tool returns the aggregate of those, nor when it is preferable to call this single tool instead of the individual listers. The reader must infer usage from the 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?

With no annotations, the description carries the full burden. It states the tool returns the complete schema, which clearly implies a read-only operation with no side effects. The verb 'get' and the phrase '用于检查' (for checking) reinforce this. It does not delve into edge cases like authentication or session prerequisites, but for a simple getter this is adequate.

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, front-loaded sentences. The first immediately states the action and resource; the second gives the purpose. Zero filler, every word 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 parameterless getter with no output schema, the description is essentially complete. It tells the agent what it returns (full Formily Schema JSON) and why (to inspect structure). It could optionally mention that a session must exist, but the phrase 'current session' implicitly covers that, and sibling tools like get_session handle session management.

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 coverage is 100% (vacuously). Per guidelines, 0 parameters earns a baseline of 4. The description does not need to elaborate on parameter meaning since there are none.

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

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

The description clearly states the specific verb ('获取' – get) and resource ('完整 Formily Schema JSON' of the current session), and even clarifies its purpose ('用于检查当前表单结构' – for checking the current form structure). This distinguishes it from sibling setter tools like set_full_schema, making its role obvious.

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 provides a clear context of use – to inspect the current form structure – which implies it is a read-oriented tool. However, it does not explicitly contrast with alternatives (e.g., get_data_config or get_template_detail) or state when not to use it. The purpose statement gives enough inference, but explicit exclusions would be stronger.

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 behavioral burden. It implies a read-only operation via the word 'view/查看', which is helpful, and lists the returned data points. However, it doesn't disclose what happens if no active session exists or other edge-case behavior, leaving some gaps for a zero-annotation tool.

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

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

The description is a single efficient sentence that front-loads the purpose and appends the usage timing. Every word 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?

For a zero-parameter read tool with no output schema, the description is largely complete: it states the purpose, the scoped data returned, and the recommended call timing. It could note behavior when no session exists, but nothing critical is missing for a tool this simple.

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 input schema is an empty object, so there is nothing to document. Per baseline, a 0-parameter tool deserves a 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 states a specific verb (view/查看) and resource (current editing session) and lists the exact contents it exposes: template ID, version ID, component count, formula count. This clearly distinguishes it from siblings like get_template_detail and 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 description gives explicit timing guidance: use before design or save to confirm state (设计前/保存前用于确认状态). It provides clear context for when to call, though it doesn't explicitly name exclusions or alternative tools.

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 burden of behavioral disclosure. It adds the session-scoping context ('当前会话') but doesn't disclose behavior when no session is active, whether it errors, or what the returned JSON structure looks like. Minimal beyond the name.

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 that front-loads the action and resource. No wasted words or redundant restatement of the name.

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 getter, the description is adequate but lean. Given the dense sibling set of session-related tools (create_preview_session, get_session, set_table_template), it doesn't clarify what 'current session' means or what happens without an active session. An agent might call it at the wrong time.

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 schema and description have nothing to document. Baseline 4 applies since there is no parameter burden to compensate for.

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 ('获取'/get) and resource ('表格模板 JSON'/table template JSON), and scopes it to the current session. It distinguishes itself from set_table_template (which sets the template) but doesn't differentiate from similar getters like get_template_detail, get_schema, or get_data_config.

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

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

No guidance is provided on when to use this tool versus its many sibling getters (get_template_detail, get_schema, get_data_config) or which session state is required. An agent cannot determine the right selection context from the description 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 are absent, so the description carries the full behavioral burden. It discloses the key trait — this is a read-only operation that does not start an editing session — which is genuinely useful and non-obvious given select_template exists. However, it does not cover authentication requirements (a login sibling exists) or the return format/pagination behavior, leaving gaps a no-annotation tool should ideally fill.

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 no filler. The primary action and version scope are front-loaded, and the differentiating view-only note comes second. Slightly more could be packed in (e.g., auth), but for its length it is well-structured and efficient.

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 tool with one parameter and no output schema, the description covers what it returns (complete details with the three version states) and its non-mutating behavior. The lack of an output schema means return structure is uncharacterized, but the summary of returned version info partially compensates. Reasonably complete for the tool's simplicity.

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

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

Schema coverage is 100% — the single templateId parameter is already described as '模板 ID'. The description adds no parameter-level meaning beyond what the schema provides, so the baseline 3 applies. Nothing more is needed for a one-parameter numeric 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?

States a specific verb+resource ('获取模板完整详情') with explicit scope (includes draft, current, and enabled version info). The closing note '不加载到编辑会话，仅查看' differentiates it from the sibling select_template and from list_templates/list_template_versions, which are coarser or version-specific reads. An agent can distinguish this from siblings without opening 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 phrase '不加载到编辑会话，仅查看' gives clear usage context — use this when you only need to inspect details, not when you intend to edit (which implies select_template). This is explicit enough as an implicit contrast, though it does not name select_template directly or state explicit when-not conditions beyond the view-only framing.

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

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

No annotations are provided, so the description must disclose behavioral traits. The description says 'create' (implying a mutation) but does not mention any side effects, permissions, or impact on existing data. It also does not describe what the function returns or how the created skeleton is used. This is a minimal disclosure for a mutation tool.

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

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

The description is a single, focused sentence that is appropriately concise and front-loaded with the purpose. It is not bloated, but it may be too terse to cover necessary 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?

Given the tool has 5 parameters (4 required), no output schema, and no annotations, the description is severely underspecified. It does not cover parameter usage, return values, side effects, or any prerequisites. An agent cannot reliably determine how to call this tool correctly from the provided information.

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 20% (only rowCount has a description). The description itself does not explain any of the five parameters, including required ones like name, title, columns, and their sub-properties. The description adds no semantic meaning beyond what the schema provides, leaving agents to infer parameter purposes from names alone.

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

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

The description clearly states the tool's purpose: creating a fixed-row table skeleton, and mentions a specific use case (parallel determinations). However, it does not differentiate from similar siblings like init_array_table or init_form_table, leaving some ambiguity about when this specific tool should be chosen.

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

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

The description provides a context for use ('suitable for fixed row scenarios like parallel determination'), but it does not explicitly mention when not to use this tool or point to alternative siblings. The usage guidance is implied rather than 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?

With no annotations provided, the description bears the full burden of disclosing behavioral traits. It states the creation of a skeleton and the path format, but does not disclose whether the operation overwrites existing data, whether it is idempotent, any side effects, or required prerequisites. For a mutation tool, this is a notable deficiency.

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 concise sentence that front-loads the core purpose ('创建自增表格骨架') and then adds a semantic detail about field paths. There is no redundancy or filler; it is well-structured and easy to parse.

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

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

For a tool that creates a table skeleton with multiple parameters and no output schema, the description lacks essential contextual details. It does not explain what happens on success (e.g., return value), whether it overwrites an existing table, or how it interacts with other table configuration tools. The given information is insufficient for an agent to call it correctly without risk of unintended consequences.

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 75%, meaning most parameters are already described. The description adds the field path convention 'tableName.colName.fieldName', which provides meaning not present in the schema's individual field descriptions. However, it does not elaborate on parameters like name, title, or parentPath beyond what the schema already conveys, so the added value is limited.

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

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

The description clearly states the tool creates an auto-increment table skeleton with sequence/operation columns and an add button. It differentiates itself from sibling tools like init_form_table or init_array_fix_table through the explicit 'array table' focus and the auto-increment aspect. The verb-resource combination is specific and unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives such as init_form_table or init_array_fix_table. The description does not mention conditions, exclusions, or the context that would make this the preferred choice. This is a significant gap given the presence of several similar table-related tools in the sibling 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?

With no annotations, the description carries full burden. It only states that a matrix layout is created but gives no information about side effects (e.g., whether it overwrites existing tables, whether it's reversible), required permissions, or what happens to existing form structure. Lacks any behavioral detail beyond the bare action.

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 – very concise. However, conciseness is not a virtue when it omits critical information. It is too under-specified to be considered well-structured for an agent's 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 tool with 5 parameters, no schema descriptions, no annotations, and no output schema, the description is severely incomplete. It offers no context on parameter semantics, usage conditions, or expected effects, making it inadequate 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 0%, so the description must compensate, but it provides no explanation of parameters such as name, title, rows, cols, or parentPath. The agent cannot infer parameter meaning or relationships from 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?

The description states a clear purpose ('创建表单内 Table/TableRow/TableCell 矩阵布局' – create a Table/TableRow/TableCell matrix within a form), which is a specific verb and resource. However, it doesn't distinguish from closely related siblings like init_array_table or init_array_fix_table, nor does it clarify what 'matrix layout' entails relative to other table-initialization tools.

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

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

No guidance on when to use this tool versus alternatives. It doesn't mention any conditions, prerequisites, or exclusions. The agent is left to infer context from the sibling 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?

Annotations are absent, so the description carries the full burden. It mentions that the row is empty and inserted at a specified index, which is useful, but it doesn't disclose what happens to existing rows (shifted down?), whether the insertion triggers other side effects (like recalculation of formulas), or whether there are any limits. The mutating nature is clear from 'insert', but the behavioral detail is thin.

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 in Chinese is concise and directly states the core action. No filler words. The structure is fine, though it could be expanded slightly with a usage hint without violating conciseness.

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 mutating tool with no annotations, no output schema, and a single parameter, the description is minimal. It lacks context about the target table (which table? the current one?), the indexing base, and any side effects. Sibling tools like delete_row and init_array_table suggest a spreadsheet context, but this isn't clarified. The description is adequate only if the context is obvious from the system, which is not guaranteed.

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 only one parameter 'at' with no description, and the description adds the meaning 'specified row index', which is helpful. However, it doesn't explain the indexing semantics (0-based vs 1-based) or if 'at' refers to a row number in the spreadsheet. With 0% schema coverage, the description does add value but only partially compensates for the missing 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 the verb 'insert' and the resource 'row' at a specified row index, which clearly identifies the operation. It doesn't explicitly differentiate from sibling tools like delete_row, but the purpose is specific enough that an agent can understand what it does without opening the schema.

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 guidance on when to use this tool versus alternatives like init_array_table or set_spreadsheet_cell, and doesn't mention any constraints or context (e.g., whether the row is inserted in a table or array, or after which operation it should be called). There is no exclusion or prerequisite information.

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 only states the function and gives a hint about categoryId. It does not describe the return format, ordering, error conditions, or side effects. For a list operation, this is minimal and leaves the agent uncertain about what to expect from the response.

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 two clauses, front-loaded with the action ('获取所有检测分类列表'). It is concise without unnecessary elaboration, though it could be more structurally separated to clearly distinguish the action from the usage hint. Still, it earns its place and is easy to parse.

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

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

For a simple list operation with no output schema, the description gives the purpose and a usage hint. However, it does not describe the structure of the returned list (e.g., that each item contains a categoryId field), which an agent needs to correctly extract the ID. Without an output schema, the description should compensate with more detail about the response shape, so it falls short of being 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?

There are zero parameters, and the schema coverage is 100% trivially. The description does not need to add parameter details since there are none. The baseline for a 0-parameter tool is 4, and the description is consistent with 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?

States a specific verb ('获取' meaning 'get') and resource ('检测分类列表' meaning 'detection category list'), which clearly identifies the tool's function. It also adds context that categoryId is needed when creating templates, which clarifies its role. However, it does not distinguish itself from the sibling get_category_tree, which might also return categories, so it lacks explicit 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?

Provides a usage hint: that categoryId is needed when creating templates, implying this tool is the source for that ID. However, it does not explicitly state when to use this tool versus alternatives like get_category_tree, nor does it mention when not to use it. The guidance is implicit rather than 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. The verb '列出' implies a read-only operation, but it does not explicitly state that no modifications are made, nor does it mention any other behaviors such as potential ordering, recursion depth, or limitations. For a simple list tool this is adequate but not fully transparent.

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, tightly worded sentence that states the core action (list all components), the format (tree structure), and the included fields (path, identifier, type, title). There is no filler or redundancy; every clause earns its place and the primary action is front-loaded.

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

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

For a parameterless tool with no output schema, the description is fairly complete: it explains what the tool returns (a tree of components with specific fields) and the scope (current form). Missing are details about the exact return structure or any caveats, but these are minor for a simple listing operation.

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 accepts zero parameters, and the schema is empty (100% schema description coverage). The description does not need to add parameter details since there are none, and it correctly avoids inventing any. Per the rubric, a baseline of 4 applies for 0-parameter tools.

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 resource ('当前表单中所有组件'), and clearly states the output is a tree structure with each component showing path, identifier, type, and title. This distinguishes it from sibling tools like list_component_types (which lists types) and get_schema (which gets the schema), making its purpose unambiguous.

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 implicitly indicates this tool is for retrieving the current form's component tree, which is clear enough for a basic use case. However, it does not explicitly state when to use it over alternatives (e.g., when needing a hierarchy vs. a flat list, or when to use get_schema instead), nor does it mention any constraints 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?

无注解提供，描述需承担行为透明度负担。描述说明了列出类型这一只读行为，但未提及返回格式、是否分页、是否包含已废弃类型等细节。对于简单列举工具，这种缺失可接受，但未完全披露，评3分。

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?

两句话，前句定义工具范围，后句给出关键用法关联，无冗余信息。信息密度高且结构清晰。

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?

对于零参数只读列表工具，描述已足够：明确列出什么、与谁关联。缺失返回格式和细节，但通过惯例可推断，且没有输出模式负担，完整性良好。

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 覆盖率为100%，描述额外说明了此列表与 add_component 的 type 参数关联，为语义提供了上下文。虽然未描述参数（因为没有），但为工具用途提供了宝贵信息，符合0参数基线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?

描述明确指出列出编辑页组件库的全部类型，并与平台设计器左侧面板一致，具有明确动词和资源。与兄弟工具 list_components（列出组件实例）区分清楚，且点明了服务于 add_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?

描述说明 add_component 的 type 参数从此列表选择，提供了明确的使用场景和关联工具。虽然没有显式说明何时不使用，但隐含了作为前置查询的用途，且无其他替代工具，评分4合理。

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 exist, so the description carries the full burden of behavioral disclosure. It conveys only that the operation is a passive 'list' (implying a benign read), but says nothing about the return format, ordering, pagination, or what fields each configuration item will contain. For a tool with zero annotation coverage, this is a thin disclosure.

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. It states the action and target immediately. It is appropriately short for a zero-parameter tool, though it leans toward under-specification in substance rather than demonstrating deliberate conciseness with rich 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 simple zero-parameter read tool, the description is minimally acceptable, but it misses the only thing an agent needs to know: what the returned 'detection date configuration items' look like and what the response contains, especially given there is no output schema to fill this gap. No mention of what 'current' refers to leaves the agent without full 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?

The tool has zero parameters and schema coverage is 100% (vacuously, since there are no properties). Per the rubric, 0-parameter tools receive a baseline of 4; the description has no parameters to explain, so no added meaning 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?

The description states a specific verb and resource: 'List current detection date configuration items.' It is clearly the read counterpart to sibling add_detection_date_item and remove_detection_date_item, so an agent can distinguish it. However, 'current' is vague (current to what context?) and 'detection date configuration items' is not expanded, leaving some ambiguity about 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?

No guidance is provided on when to call this tool versus its siblings. It does not say 'use this to review existing detection-date items before adding or removing one,' nor does it mention any exclusions or prerequisites. An agent gets no routing information beyond what the name implies.

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 must carry the behavioral disclosure burden. It states the tool lists functions, which implies a read-only operation, but it does not explicitly mention that it has no side effects, requires no authentication, or what the output looks like. This is a minor gap for a simple list tool, but the description is not misleading.

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, concise sentence with no filler. It front-loads the core purpose (list functions) and includes the count, making it efficient and immediately 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 simple list tool with no params, no output schema, and no annotations, the description provides enough information for an agent to invoke it: it lists all built-in expression functions. While it lacks details about output format or sorting, the tool is trivial to call correctly. A slightly higher score is not warranted because the description doesn't describe the expected return shape.

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 coverage is 100% (empty schema). Per the rubric, a zero-parameter tool receives a baseline of 4. The description adds nothing about parameters because there are none, so the baseline stands.

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

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

The description clearly states the action (list), the target resource (ELN expression engine built-in functions), and even specifies the count (22). This makes the tool's purpose unambiguous and distinguishes it from sibling list tools like list_components or list_templates, which target different resources.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. While it's a specific list tool, the agent is given no explicit context about when it should be invoked (e.g., before modifying formulas).

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 burden of behavioral disclosure. It only states that it lists formulas, without explicitly noting that it is a read-only operation, whether authentication is required, or if there are any side effects. For a tool with zero annotation coverage, this is a 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, direct sentence that immediately conveys the core function. There is no fluff or repetition, and the key scoping detail ('current session') is front-loaded. It is appropriately concise for a simple list tool.

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 operation with no parameters and no output schema, the description is adequate but minimal. It specifies the scope ('current session') and the resource, but does not describe the return format or any filtering options, which could leave an agent uncertain about the exact output structure.

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 0 parameters, and the schema coverage is 100% (trivially, since there are none). As per the baseline for 0 parameters, the description does not need to add parameter-specific details, and it meets this expectation without redundancy.

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 the specific verb 'list' and the resource 'calculation formulas' scoped to 'current session', which clearly identifies what the tool does. It is distinct from sibling tools like list_templates, list_components, and list_output_items, so an agent can differentiate it without opening a schema.

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 'current session' provides a context cue, but there is no explicit guidance on when to use this tool versus alternatives like list_output_items or list_expression_functions. No exclusions or alternative suggestions are given, leaving usage partially 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 burden. It discloses that this lists output value configurations for the current session, which is the core behavior. However, it does not describe the output format, whether all configuration fields are returned, or ordering — though for a simple listing tool this 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, compact sentence with zero waste. The resource and scope are declared immediately and nothing extraneous is included. Ideal conciseness for a simple list tool.

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 listing tool with no output schema, the description fully covers what an agent needs: what it lists and the session scope. No missing information would prevent 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?

The tool has zero parameters and schema coverage is trivially 100%, so there is nothing for the description to explain. Per the baseline rule for 0-parameter tools, the description need not add parameter detail. It correctly matches the empty 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?

Description states a specific verb ('列出' - list) and resource ('输出值配置' - output value configurations) scoped to the current session. The phrase '当前会话中' adds scope clarity that distinguishes it from sibling tools like add_output_item, remove_output_item, and update_output_item.

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 as a read/query operation for retrieving output configurations, and the 'current session' scope provides some context. However, it does not explicitly state when to prefer it over alternatives, nor does it mention that it complements the related add/remove/update_output_item tools. Usage is implied but 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?

No annotations are provided, so the description must fully disclose behavioral traits. It only states the basic function (querying samples) without mentioning return format, authentication needs, pagination, or any side effects. This leaves a significant gap for a read operation, especially with 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?

The description is two concise sentences with no redundancy. The core purpose is front-loaded, and the second sentence adds useful contextual information without waste.

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 (one parameter, no nested objects) and the clear purpose, the description is minimally viable. However, with no output schema and no annotations, it lacks details about the return structure or limitations, so an agent may need additional context to fully interpret the result.

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 already documents the single parameter categoryId with a description ('分类 ID'), and the schema description coverage is 100%. The tool description does not add any extra meaning beyond referencing 'specified category', so it earns the baseline score for schema-covered 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?

The description clearly states the action (查询/query) and resource (样品列表/sample list) with a specific scope (指定分类/under specified category). The added context about template creation further clarifies its role, making it distinct from other list tools like list_categories.

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

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

The description provides a concrete usage scenario (创建模板时/when creating a template) that implies when to use this tool. However, it does not explicitly name alternative tools or state when not to use it, so it falls short of the 'explicit when/when-not/alternatives' level.

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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It mentions that it returns certain fields, but does not explicitly state whether this is a read-only operation, whether authentication is required, or how pagination behaves beyond the default values. For a query tool, these are relatively safe assumptions, but the lack of explicit statements leaves room for ambiguity, hence a 3.

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

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

The description is a single sentence that is concise and front-loaded with the core action and resource. Every word contributes meaning, and there is no redundant or filler content. It efficiently communicates the purpose without unnecessary elaboration.

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 paginated list tool with only two numeric parameters and no output schema, the description is largely adequate. It states the return fields and implies pagination. While it does not specify the exact structure of the response or any ordering, the tool's simplicity means these are minor gaps. The description covers the essential context needed for an agent to call 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 schema covers both parameters (current and pageSize) with descriptions, so the baseline for parameter semantics is 3. The tool description does not add any extra meaning beyond what the schema already provides—it only mentions 'paginated', which is already implied by the parameter names and defaults. No additional syntactic or format details are offered.

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

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

The description clearly states a specific verb '分页查询' (paginated query) and resource '提交日志' (submission logs), and it lists the return fields (submission type, creator, task ID). This unambiguously distinguishes it from the sibling tools, none of which deal with logs, so an agent can tell it apart without deeper inspection.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. While it is implicitly the tool for listing submission logs, there is no explicit context such as 'use when you need to retrieve submission history' or mention of what not to use it for. This leaves the agent to infer appropriate usage.

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

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

No annotations are provided, so the description must carry the full burden. It states this is a query (read) operation and lists return fields (ID, name, status, version). However, it does not explicitly confirm read-only behavior, side-effect absence, or any operational limitations. This is acceptable for a simple list tool but lacks depth, so 3.

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 no filler. The main purpose is front-loaded, followed by filter options and return fields. Every sentence adds value, achieving optimal conciseness.

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 paginated listing tool with 4 optional parameters and no output schema, the description adequately covers purpose, filters, and return fields. It lacks guidance on ordering and differentiation from search_templates, but the core usage is clear. Given the moderate complexity, this is reasonably complete, hence 4.

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 each parameter already has a clear description. The description text adds no extra meaning beyond what the schema provides—it re-states '按分类筛选' and '按名称搜索' which are equivalent to categoryId and name descriptions. This meets the baseline of 3.

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 pair: '分页查询模板列表' (paged query template list). It specifies filtering/searching and return fields. However, it does not explicitly differentiate from sibling 'search_templates', despite overlapping capabilities (search by name). This is a minor gap, so 4 rather than 5.

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

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

The description implies usage (for listing templates with pagination and optional filters) but does not provide explicit when-to-use vs alternatives. There is no mention of when to prefer this over 'search_templates' or 'get_template_detail'. Usage is inferred from context, not stated, so 3.

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 must disclose behavior itself. It only implies a GET (read-only) operation, but says nothing about pagination, sorting, error conditions, or what data is returned. This is a minimal disclosure that does not adequately inform the agent.

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?

While the description is brief, it is under-specified rather than concise. It is a sentence fragment that adds little beyond the tool name, and does not effectively front-load useful information. It does not earn its place because it conveys almost no operational value.

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 one parameter, no output schema, and no annotations, the description is severely lacking. An agent has no information about expected input values, output format, or conditions for use, making the tool effectively unusable based on the description alone.

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 one parameter (templateId) with no description, and schema coverage is 0%. The description does not mention templateId or explain how it should be used, entirely failing to compensate for the schema's lack of 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 'GET 版本历史列表' states the action (GET) and resource (version history list), which is clear on the surface. However, it is essentially a fragment that restates the tool name (list_template_versions) without adding any nuance or distinguishing it from siblings like list_templates or get_template_detail.

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 alternatives. No context about use cases, prerequisites, or exclusions is provided, leaving the agent without any basis for choosing this over other list/detail tools.

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 discloses that login uses browser automation and that the token is cached for 24 hours, which are useful operational facts. However, it does not mention side effects such as invalidating a previous token, behavior on failure (e.g., network errors, CAPTCHA), or whether it is idempotent. These gaps leave uncertainty for an agent invoking the tool.

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

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

The description is concise—three short sentences, front-loaded with the primary purpose, then usage condition and caching detail. Every sentence is informative and there is no redundancy. It is well-sized for the tool's complexity.

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 that there is no output schema, the description conveys the essential return value implicitly (JWT token) and provides the key timing (cache 24h). It implies that this tool is a prerequisite for other operations (since it creates the token). It lacks details on error handling or explicit instructions to call it before other tools, but the core context is present. For a moderately complex tool, this is adequate.

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?

Although the schema already covers both parameters (username and password) with descriptions, the tool description adds meaningful semantics by noting that both are optional and default to configured values (admin username and configured password). This clarifies that an agent can omit them, which is not evident from the schema alone. The description adds value beyond the structured 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 clearly states the action (login via browser automation), the target resource (ELN platform), and the outcome (obtaining a JWT token). It also gives the context for when it is appropriate (first use or token expiry), which distinguishes it from sibling tools like check_auth that presumably validate an existing token. This is a specific verb+resource definition that leaves no ambiguity.

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?

Explicitly states when to use the tool: 'on first use or when the token expires'. This gives clear context for calling it. However, it does not mention alternatives (e.g., using check_auth to verify an existing token) or conditions under which it should not be called. Including such exclusions would push this to a 5.

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

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

No annotations are provided, so the description must carry full behavioral disclosure. It says only 'merge cell range' and offers no information about destructive effects, data loss, reversibility, or any side effects of merging. For a mutating operation, this is a critical omission.

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 single sentence is extremely short and front-loaded, but this is under-specification rather than concise efficiency. Essential details about parameters and behavior are absent, so brevity here is a defect, not a strength.

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 four required parameters, no output schema, and no annotations, the description provides almost no contextual information. An agent would not know the coordinate system, range validation, or side effects. The definition is completely inadequate for safe and 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 0%, and the description does not explain any of the four parameters (startRow, startCol, endRow, endCol). It fails to define what these coordinates mean, their constraints (e.g., start <= end), or the range they form. The description must compensate but 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 '合并单元格区域' (merge cell range) clearly states the verb and resource, making the basic purpose understandable. However, it adds little beyond a direct translation of the tool name and does not differentiate the operation from siblings like set_cell_style or insert_row with any specific detail about the range or context.

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 alternatives. The description does not mention scenarios, prerequisites, or conditions under which merging cells is appropriate or preferable to other cell operations, leaving the agent without decision-support information.

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 burden of behavioral disclosure. It does disclose a key behavioral trait: 'delete first then add' (先删后加), indicating a specific operation order and implying mutation. However, it does not mention potential side effects, error conditions, or reversibility. While more informative than a generic 'move' statement, it is minimal and leaves out important behavioral context.

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, compact sentence that states the action and the key behavior. It is efficient with no wasted words, and the core information is front-loaded. However, it omits parameter details, so while concise, it sacrifices completeness for brevity.

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 tool has three parameters, one required, no output schema, and no annotations, the description is inadequate for correct invocation. It does not explain the purpose of the required 'path' parameter or the optional 'newName' and 'newParentPath'. It also fails to describe return values or error behavior. An agent would likely guess incorrectly about parameter usage, making this definition incomplete.

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 parameter meaning. The description mentions 'new parentPath' but does not explicitly name the 'newParentPath' parameter, nor does it explain 'path' or 'newName'. Agents cannot infer what each of the three parameters represents from the description alone, especially 'newName'. This is a significant deficiency given the low 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 clearly states the action: move a component to a new parentPath, with the behavior 'delete first then add'. The verb 'move' and resource 'component' are specific and distinguish it from siblings like copy_component, reorder_component, add_component, and remove_component. This is a concise and unambiguous purpose statement.

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 specify when to use this tool versus alternatives like copy_component or reorder_component. It only states what it does, not when it should be chosen. There is no explicit when-not or alternative routing, leaving the agent to infer usage from the tool name and sibling context. This is a clear gap in guidance.

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. It discloses a non-obvious behavior: deleting a container component also deletes its children. It also states the scope ('from the current form'). This goes beyond a bare 'delete component' and provides meaningful behavioral insight, though it does not mention reversibility or permissions.

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 short, dense sentences with no filler. The core action is stated first, and the important container-behavior is appended concisely. It earns its place fully.

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 destructive operation with no output schema, this description is sufficient. It states what is deleted, the context (current form), and a critical side effect (cascade). It does not cover error cases or auth, but those are often implicit for such tools and not required 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?

Schema coverage is 100% and the schema already describes the 'path' parameter with examples. The description adds no additional parameter-level detail beyond the schema, so the baseline of 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?

The description clearly states the action (delete specified component), the object (component in the current form), and a key distinguishing detail (supports container components, deleting children). This differentiates it from sibling add/copy/move/reorder tools unambiguously.

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?

While it doesn't explicitly name alternatives or exclusions, the description makes the operation's scope and effect clear, so an agent can infer when to use it. It provides one use-case nuance (container deletion cascades), but does not contrast with other removal tools like remove_validator or remove_formula.

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

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

No annotations are provided, so the description must carry the burden of behavioral disclosure. It only states the action (delete) without mentioning side effects, failure behavior, permissions, or consequences. This is minimal coverage for a mutating operation.

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

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

A single concise sentence that conveys the essential action. It is not bloated, though it lacks structure such as examples or edge-case hints. Efficiency is good.

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 delete operation with one param, the description is adequate. It does not explain what a detection date configuration item is, but given the low complexity and complete schema, no critical information 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 schema already documents the sole parameter 'id' as '配置项 ID' with 100% coverage. The description adds no additional semantic value beyond what the schema 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 '删除一条检测日期配置项' clearly states the verb (delete) and the resource (detection date configuration item). It is unambiguous, though it does not differentiate from sibling tools like add_detection_date_item or list_detection_date_items.

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

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

No guidance is provided on when to use this tool versus alternatives. The sibling list includes many similar operations, but the description gives no context, prerequisites, or exclusions—agents must infer usage from the 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?

No annotations are provided, so the description carries the full burden. It only states that it deletes a formula by ID, but does not disclose side effects like irreversibility, permission requirements, behavior for non-existent IDs, or any impact on dependent components.

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, concise sentence with no redundant words. It is front-loaded and efficiently communicates the core action and method.

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 delete operation with no annotations and no output schema, the description is minimal. It lacks information about return values, error handling, or consequences of deletion, which an agent would need to understand fully before calling the tool safely.

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 already describes the id parameter as '公式 ID' with 100% coverage. The description's mention of '按 ID' aligns with the schema but adds no additional semantic meaning beyond what is already documented.

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

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

The description clearly states the verb '删除' (delete) and the resource '计算公式' (calculation formula), along with the method '按 ID' (by ID). This distinguishes it from sibling tools like add_formula, list_formulas, and update_formula, though it doesn't explicitly contrast 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 guidance on when to use this tool versus alternatives, such as whether it should only be called when the formula exists, or any prerequisites or exclusions. The description simply states the action without contextual usage advice.

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

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

No annotations are provided, so the description carries the full burden. It only states that it deletes, with no disclosure about side effects, reversibility, permissions, or error handling. For a mutation tool, this is a significant 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, efficient sentence with no wasted words. It directly conveys the action and target, and the structure is clear and front-loaded.

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 delete operation with one fully documented parameter and no output schema, the description is minimally sufficient. However, it omits any mention of preconditions, whether deletion cascades, or what happens on failure, leaving some ambiguity for an agent.

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 documents the 'id' parameter as '输出值 ID' (output value ID), and description coverage is 100%. The description confirms deletion by ID but adds no new semantic information beyond what the schema provides, 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?

The description '按 ID 删除输出值配置' (Delete output value configuration by ID) clearly states a specific verb (delete), a resource (output value configuration), and the means (by ID). This distinguishes it from sibling tools like add_output_item, update_output_item, and list_output_items, though it does not explicitly name 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?

The description gives no guidance on when to use this tool versus alternatives such as update_output_item or add_output_item. It implies deletion usage but does not state context, prerequisites, or mention any sibling tools.

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 of behavioral disclosure. It only states the action (delete reactions) without explaining side effects, whether it fails if no reactions exist, permissions required, or how the path parameter is interpreted. This lack of behavioral context makes it risky for an agent to call confidently.

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 extremely concise—a single sentence—which is appropriate for a simple utility. It front-loads the action and object. However, its brevity borders on under-specification, but as a style it is clear and direct, earning a solid 4.

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 only one parameter and no annotations, the description still falls short. It does not explain the meaning of 'path', nor does it mention what happens if reactions do not exist or how this interacts with set_reactions. The agent lacks sufficient context to use the tool correctly beyond a guessed 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?

Schema description coverage is 0% and the description does not explain what 'path' refers to (e.g., the path to a field within a schema). The only parameter is a bare string with no meaning added. The agent has no indication of valid formats, examples, or relationship to other fields.

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 '删除字段的 x-reactions' (delete field's x-reactions) clearly states the verb (delete/remove) and resource (x-reactions on a field). It is specific and understandable. While it doesn't explicitly reference the sibling set_reactions, the verb 'remove' inherently contrasts with 'set', making the purpose distinguishable without extra text.

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

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

No guidance is given on when to use this tool, what prerequisites are needed, or how it compares to set_reactions. There is no mention of typical invocation scenarios, edge cases, or alternatives. The agent is left to infer usage solely from the name and description.

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 responsibility for behavioral disclosure. It states the delete action but does not mention side effects (e.g., index shifting, irreversible changes, validation errors on out-of-bounds index, or whether the operation is idempotent). This is a significant gap for a mutation tool.

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

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

The description is a single front-loaded sentence with no wasted words. While extremely terse, it is appropriately sized for a simple delete operation, though it could benefit from a bit more structure for parameter clarity.

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 simplicity of the operation and lack of output schema, the description is incomplete. It does not specify what 'x-validator' refers to, how to obtain the index, or any prerequisites (e.g., path validity). An agent would need to infer these from context, which is risky.

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 explain parameter meanings. It mentions 'index' but does not clarify that 'path' identifies the target component or that 'index' is the zero-based position of the validator. No extra semantics are added beyond the schema's property names.

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 specifies the verb 'delete' and the resource 'x-validator rule', with the method 'by index'. It distinguishes from siblings like set_validator (which adds/updates) and remove_reactions (different resource). The action and target are unambiguous.

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

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

No guidance on when to use this tool versus alternatives is provided. It does not mention the context (e.g., which component or schema) or conditions under which removal is appropriate. Siblings like set_validator exist, but the description does not differentiate usage scenarios.

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 only says a sort value is set and does not reveal how the reorder behaves — whether it is a full reorder, how conflicts with other components' x-index are resolved, or whether the change is reversible.

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 text is extremely short, but this is under-specification rather than efficient conciseness. It front-loads nothing useful and every dimension suffers from the lack of detail.

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 mutating operation with no annotations, no output schema, and zero schema descriptions, this description is inadequate. An agent cannot reliably determine what index values are valid, what path refers to, or what the outcome of a call will be.

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 either parameter. The meaning of 'path' (likely the component identifier) and 'index' (the sort position, and its bounds/format) is left entirely to inference, with no compensation from 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?

The description states a specific verb and resource: '设置组件 x-index 排序值' (set component x-index sort value). It is clear this reorders components, but it does not distinguish itself from similar siblings like move_component or reorder_formulas, which appear to overlap in function.

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

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

No guidance is provided on when to use this tool versus alternatives. Given the presence of move_component and reorder_formulas, an agent receives no help deciding which one is appropriate for a given task.

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 of disclosing behavior. It only says 'reorder,' which implies mutation but does not explain persistence, validation, error handling, scope (e.g., which template), or any side effects. The agent cannot anticipate what happens beyond the immediate action.

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, compact sentence that front-loads the action and target. There is no extraneous wording, and it is appropriately sized for the tool's simplicity.

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, but with no annotations and no output schema, the description must cover essential behavior. It lacks details on scope (which template/formula set), idempotency, error behavior for invalid ids, and whether the reorder is persistent. The minimalism leaves critical context unstated.

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 defines 'ids' as an array of numbers but provides no description. The phrase '按 ID 顺序' (in ID order) hints that the array specifies the order, but it is ambiguous—it could mean sorting by ascending IDs rather than taking the provided sequence as the new order. The description adds minimal clarification and relies on inference.

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

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

The description clearly states the action (reorder), the target (expressionItems), and the manner (by ID order), making it distinct from sibling tools like add_formula or list_formulas. Even without a title, the verb+resource+modifier is unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. It is purely a declarative statement, leaving the agent to infer context from the sibling list, which is insufficient for effective selection.

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 burden of disclosure. It adds a valuable, non-obvious behavioral fact: clearing the schema does not affect data already saved to the server (不影响已保存到服务器的数据). This caveat meaningfully shapes an agent's expectations about what this destructive-sounding operation actually touches.

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 waste. The primary action is front-loaded and the critical caveat about server data follows immediately. Every word 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 parameter-less tool with no output schema and no annotations, the description is nearly complete: it states the action, the intent, and the key safety caveat. It could marginally add explicit contrast with set_full_schema as an alternative, but nothing essential is missing 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?

The tool takes zero parameters, so the baseline is 4 per the rubric. The description correctly suggests no configuration is required; there is nothing further the description needs to explain about 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?

The description uses a specific verb (清空/clear) with a specific resource (当前表单 Schema), and adds the intent (重新开始设计/restart design). The purpose is unambiguous and distinct from siblings like set_full_schema or get_schema, though it doesn't explicitly name 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?

The phrase '重新开始设计' (restart design) implies when this tool is appropriate — when the user wants to start over from scratch. However, there is no explicit when-not-to-use guidance or naming of alternatives, leaving the agent to infer the use case.

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 present, so the description carries the full burden of behavioral disclosure. It only states that it is a PATCH operation that saves three fields, implying a write operation but without disclosing side effects like overwriting existing data, requiring authentication, or expected response. The limited transparency leaves significant uncertainty about the tool's 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, compact sentence that is front-loaded with the HTTP method and the key fields. There is no redundant or filler content; every word contributes to conveying the core action. This is an exemplary level of conciseness.

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 large number of sibling tools, the lack of parameter details, and no output schema, the description is insufficient for an agent to correctly call the tool in context. It does not explain what formTemplateJson, extra, or tableTemplateJson represent, nor when to use this over other template-related tools. The information is too minimal for confident usage.

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, so a baseline of 4 applies. The description adds value by naming the three fields involved (formTemplateJson, extra, tableTemplateJson), which provides some semantic context beyond the empty schema. However, it does not elaborate on the structure or meaning of these fields, keeping the addition at a basic level.

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 (PATCH) and resource (saving formTemplateJson, extra, tableTemplateJson). It clearly indicates the tool performs a partial update on these template fields. However, it does not explicitly distinguish it from other template-related tools like create_template or update_template_metadata, relying on inference from the field names. The purpose is mostly clear but not fully differentiated.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention applicable contexts, prerequisites, or contrast with sibling tools like create_template or update_template_metadata. An agent would have to guess when to invoke this rather than other template save/update tools.

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 confirms this is a GET request (implying read-only), but it does not state what the response contains, whether results are paginated, default ordering, or any side effects. For a search tool with zero annotation coverage, this falls short of what an agent needs to know about its runtime 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, front-loaded sentence delivers the essential purpose and filters with zero fluff. Every word earns its place; the endpoint is given alongside the verb, and the two filters are called out explicitly. This is exemplary conciseness.

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 tool has four parameters, no output schema, and no annotations, the description is too thin. It omits pagination semantics, response shape, relationship to sibling list_templates, and any edge cases. An agent calling this for the first time would know its intent but not enough about expected behavior or how it differs from the near-sibling list_templates.

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%, so the description must compensate. It explicitly explains categoryId and name as filter criteria, which adds real meaning for two of the four parameters. However, it says nothing about current or pageSize (pagination), leaving half the parameters undocumented beyond their bare names. Partial compensation warrants a middle score.

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 (搜索/search) plus the resource (模板/templates) and even the HTTP endpoint (GET /form-template/search). It also names the two supported filters (categoryId, name), which clearly distinguishes it from sibling list_templates (which presumably lists all) and get_template_detail (which fetches a single template). This is a precise, non-tautological statement.

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 is for searching templates with optional categoryId and name filters. However, it provides no explicit guidance about when to choose this over sibling tools like list_templates, get_template_detail, or list_categories. The filtering mention gives an implicit selection criterion, but there is no when-not-to-use or 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 bears full responsibility for behavioral disclosure. It only says 'load into memory,' implying a state change but does not clarify side effects, authorization needs, or what happens to the previously loaded template. This is a significant omission for a state-mutating operation.

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

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

The description is a single short sentence, which is concise but under-specified. It conveys a minimal purpose but lacks structure or detail that would help the agent understand the tool's role. It feels like a placeholder rather than a well-crafted description.

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 large set of sibling tools and the tool's stateful nature, the description is far from complete. It does not explain the effect of loading, the difference between this and similar tools, or any prerequisites. With one parameter and no output schema, the agent needs more information to call it correctly, which 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 schema has 0% description coverage, and the description does not explain the templateId parameter beyond its existence. No format, semantics, or constraints are provided, leaving the agent without useful guidance for filling in the required 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 states the action 'select template' and what it loads (Schema/extra/table into memory), which is a specific verb and resource. However, it does not distinguish itself from the many sibling tools like get_template_detail or get_schema, and the term 'extra/table' is vague without further context.

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 alternatives. No mention of scenarios, prerequisites, or exclusions. The agent is left to infer from the name alone, which is insufficient.

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 burden of behavioral disclosure, but it is extremely terse. It does not state whether setting a style replaces existing styling, how the 'index' and 'properties' modes interact when both are supplied, whether the operation is reversible, or what the response looks like. The implied mutation behavior is left entirely to inference.

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 filler, which is appropriately compact. The tool name and description align, and the two-mode distinction is placed upfront. It's efficient, though it borders on under-specification rather than genuine economy.

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 5-parameter mutation tool with no annotations, no output schema, and 0% parameter coverage, the description is far too thin. Missing details include the semantics of each mode, how row/col are addressed, the behavior when both style and bold/italic are set, and what happens on overwrite. An agent has too little to call 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 0%, so the description must compensate. It partially does by mapping the 'style index' mode to the style parameter and 'style properties' to bold/italic, which adds some meaning beyond the raw schema. However, it leaves row/col semantics unexplained and doesn't clarify how style vs bold/italic interact, so compensation is only partial.

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 (set) and resource (cell style), and usefully distinguishes two modes: 'style index' (the style param) versus 'style properties' (bold, italic). However, it doesn't differentiate itself from sibling tools that also set things (set_property, set_spreadsheet_cell, set_enum_options), so an agent must infer which one to pick based on the cell-style context.

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

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

No guidance on when to use this tool versus alternatives. There are no when/when-not conditions, no exclusions, and no context about relationship to sibling set_* or bind_* tools. An agent gets no help routing between set_cell_style and the many other cell/template mutation tools.

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 of behavioral disclosure. It fails to mention what happens on failure (e.g., if uniqueness is violated), whether it overwrites an existing value, any side effects, or required authentication. The uniqueness constraint is mentioned but not elaborated, leaving virtually no behavioral transparency.

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, which is efficient in length, but it is under-specified. The brevity sacrifices necessary detail, so it is not a well-rounded concise description; it is simply too terse to be effective.

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 tool is a simple setter with one parameter and no output schema, the description still fails to explain what the controlled number is, when it should be set, or any constraints beyond uniqueness. It is incomplete for an agent to use reliably.

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 the description adds no meaning to the parameter 'controlledNo'. The only clue is the parameter name itself, which is insufficient. No format, example, or constraints are given, so the agent cannot infer what value to supply.

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 action ('set controlled number') but the object 'controlled number' is vague and does not specify what it is or how it relates to other template components. It does not distinguish itself from many sibling setter tools like set_property or set_enum_options, leaving ambiguity about its exact purpose.

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

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

No guidance is given on when to use this tool versus alternatives. The only hint is the global uniqueness requirement, which is a constraint on usage but does not explain the context or prerequisites needed before calling 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?

No annotations are provided, so the description carries the full burden. It discloses a key behavioral trait: existing items are not modified unless items is passed for full replacement. However, it does not describe other side effects, permissions, return values, or consequences of changing the policy. The transparency is adequate for the stated action but incomplete for a mutation tool.

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

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

The description is two concise sentences, with the primary action stated first and the key caveat second. Every word adds value; there is no redundant or vague phrasing. It is appropriately front-loaded and efficient.

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 mutation tool with no output schema and no annotations, the description covers the essential behavior (setting policy, item modification condition) but omits details like return values, what happens to existing data when policy changes, and the exact behavior of missingPolicy values. It is sufficient for basic usage but lacks some contextual depth that could be expected for a setter.

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 is 3. The description adds context by tying missingPolicy and outputFormat to the global policy and clarifying the items semantics (full replacement vs no modification). However, it does not go beyond what the schema already describes for each parameter, so it only marginally enhances parameter understanding.

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

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

The description clearly states the tool sets the global detection date policy (missingPolicy, outputFormat) and specifies it does not modify existing items unless items is provided for full replacement. This distinguishes it from sibling tools that operate on individual items (add/remove/list_detection_date_item). It is clear and specific, though it does not explicitly name alternatives.

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

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

The description implies when to use this tool (to set global policy) and mentions the condition for modifying items, but it does not explicitly state when not to use it or contrast it with item-level operations. The usage context is implied rather than explicit, so it meets the baseline but lacks guidance on 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?

With no annotations, the description carries the full burden of disclosing behavioral traits. It only says 'set', which implies mutation, but does not reveal whether options are replaced or appended, whether changes are reversible, or any permission or side-effect requirements. The agent is left guessing about the impact of the operation.

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

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

The description is a single, short sentence that is front-loaded and free of fluff. However, it is almost too terse: it omits crucial details about parameters and behavior, so while concise, it sacrifices informativeness for brevity.

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 lack of annotations and output schema, and the presence of many sibling tools, the description is incomplete for an agent to call the tool correctly. It does not explain how 'path' is specified, whether options are full replacements, or any error conditions. The agent would need to inspect the schema heavily and still might misinterpret the intended usage.

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%, so the description must compensate for parameter meaning. It mentions '可选项' (options) but does not explain the 'path' parameter (e.g., its format or how it identifies the target field) nor the required structure of options (label/value pairs). It adds only the context that this is for enum fields, which is limited value 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?

The description states a specific verb ('set') and resource (options for Select/Radio/Checkbox enum fields), making the tool's purpose clear. It differentiates from generic setters like set_property by naming the component types, though it doesn't explicitly contrast with siblings.

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

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

No guidance is provided on when to use this tool vs alternatives. There are no exclusions, prerequisites, or hints about when this is the appropriate choice among the many sibling setters (set_property, set_validator, etc.). The intended usage is only implied by the name and resource.

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

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

No annotations are provided, so the description carries the full burden. It clarifies the scope (form-level) and lists the properties affected, which helps the agent understand what gets modified. However, it doesn't disclose whether changes are persistent, whether validation occurs on the backend, or the exact effect of each property (e.g., what 'labelWrap' changes visually). For a mutation tool it provides minimal but non-contradictory behavioral context.

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 zero wasted words. The verb and scope are front-loaded, and the parameter list is placed immediately after. Every word 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 5-parameter settings tool with no annotations and no output schema, the description is fairly complete in naming the target properties and locating the UI panel. However, it omits the 'fullness' parameter entirely and gives no hints about value ranges or validation behavior. Given the tool's moderate complexity, this is adequate but leaves the agent to infer how each property maps to UI behavior, particularly for the undocumented parameter.

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%, so the description must compensate. It names 4 of the 5 parameters (labelCol、wrapperCol、labelWrap、layout) but omits 'fullness'. It doesn't explain semantics of each parameter (e.g., valid values for layout, what labelCol of a number means as a span). Naming the parameters adds some value over the bare schema, but the incomplete list and lack of value constraints leave gaps.

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 (设置/set) and resource (表单级属性/form-level properties) while explicitly listing the affected parameters (labelCol、wrapperCol、labelWrap、layout). This clearly differentiates from sibling tools like set_property (component-level) and set_full_schema, which handle different scopes.

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 表单级属性 (form-level properties) and the mention of the right-side 表单 panel imply this is for form-wide settings, distinguishing it from component-level alternatives like set_property or add_component. However, there's no explicit when-to-use vs when-not-to-use guidance, and no alternative tool is named. The context is implied rather than 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose the destructive overwrite behavior ('覆盖此前数据配置'), which is important. However, it does not mention other relevant behaviors such as whether the entire extra is replaced vs. merged, atomicity, error conditions, or return values, leaving some 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 two short sentences, front-loading the action and its scope, then stating the destructive behavior. No wasted words, and it is efficiently structured for quick parsing by an agent.

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 nested object complexity and the lack of annotation or output schema, the description is somewhat thin. It explains the tool's purpose and overwrite behavior but does not clarify the required internal structure of the 'extra' object or provide any guidance on permissions or side effects. It is adequate for a simple call but leaves room for ambiguity about constructing the object 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 schema only describes 'extra' as '完整 extra 对象' (complete extra object) with additionalProperties true. The description adds value by enumerating the three expected subfields (expressionItems, outputItems, detectionDateConfig), giving the agent concrete knowledge of what to include. It does not specify whether they are all required or their exact formats, but it goes beyond the schema's vagueness.

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 the verb 'set' and resource 'extra', explicitly enumerates the three component keys (expressionItems, outputItems, detectionDateConfig), and notes that it overwrites previous configuration. This clearly distinguishes it from incremental siblings like add_output_item, set_detection_date, and add_detection_date_item.

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 '一次性设置' (set at once) and '覆盖此前数据配置' (overwrites previous data configuration) imply this is for a full replacement rather than incremental updates, but it does not explicitly name alternatives or state when to choose this over the many sibling tools. 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?

With no annotations provided, the description carries the full burden. It does disclose the key destructive behavior: it overwrites all previous fine-grained operations. However, it doesn't mention other potential effects, such as whether it validates the schema, resets form settings, or is reversible. The overwrite warning is valuable, but a bit more detail on side effects would raise the score.

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 in Chinese: the main action, then usage, then the critical side effect. No filler. The most important information (overwrite) is placed at the end but still impactful. Ideal compactness.

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 bulk setter without an output schema, the description covers purpose, usage, and the key behavioral consequence. It doesn't mention validation or whether existing form settings (e.g., form settings via set_form_settings) are affected, but given the tool's simplicity and the overwrite warning, it's fairly complete. Slight gap on additional side effects prevents a 5.

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

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

Schema description coverage is 100% — the parameter is fully described as a complete Formily Schema object containing form and schema fields. The tool description adds no extra meaning beyond what the schema already says, so it doesn't need to compensate. 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?

The description clearly states the tool sets the complete Formily Schema JSON, which is a specific verb+resource. It differentiates from fine-grained operations by noting it overwrites them, though without naming specific sibling tools. This is sufficient to distinguish it from the many fine-grained tools in the sibling 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?

It explicitly states appropriate use cases: copying schema from templates or AI generating the full form structure in one go. It implies it is not for incremental edits by warning that it overwrites previous fine-grained operations, giving a clear sense of when to select this over tools like set_property or add_component. It doesn't explicitly enumerate alternatives, but the context is clear.

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提供安全信息，描述也未披露任何行为细节。未说明属性设置是覆盖还是合并，未提及权限要求、错误处理或对现有属性的影响。仅提到可以设置任意x-component-props或x-decorator-props字段，这属于参数类别而不是行为。整体行为透明度过低。

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?

描述仅两句话，第一句点明核心功能，第二句提供关键参考信息。结构紧凑，无冗余内容，核心信息前置，符合优秀工具描述的标准。

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?

无输出schema，描述也未说明操作成功与否的反馈方式。但对于一个修改操作，可能不需要详细返回值。不过描述没有说明错误情况、权限要求或对现有属性的影响等上下文信息，参考Skill文件可能补充部分但描述本身不算完整。在无annotations的情况下描述应承担更多责任，因此给3分。

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已覆盖100%参数，但描述额外解释了propType的含义（对应component/decorator）并指出属性名映射参考Skill文件，这为key参数提供了重要指导。相比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?

描述明确说明'修改已添加组件的属性'，准确指出了操作对象和动作。与'add_component'等新增类工具区分明显，但没有明确与'set_full_schema'等整体替换工具的区分。虽然提到了'已添加组件'，但没有明确说何时该用此工具而非其他修改工具，但目的清晰，故得4分。

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?

描述没有提供任何使用时机或替代工具的指引。没有说明何时使用本工具而非其他修改工具（如set_full_schema），也没有说明前置条件（如必须先有组件存在）。仅隐含了'已添加组件'这一前提，但缺乏明确的when/when-not说明。

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 full responsibility for behavior. It merely states the action without disclosing side effects, required permissions, mutability, or what happens to existing reactions. Nothing beyond the literal action is conveyed, which is insufficient for a tool that likely modifies state.

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

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

The description is a single sentence with no wasted words, which is concise. However, it lacks structure and is too brief to be helpful. It's not a tautology like 'Process', but it provides only the barest information. The front-loading is minimal since there's nothing more to front-load.

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 tool has two parameters (one a nested object), no output schema, and no annotations, the description is drastically incomplete. An agent cannot know what 'path' expects, what shape 'reactions' should take, or what the response will be. This is severely under-specified for a tool with 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?

Schema description coverage is 0%, so the description must explain the parameters, but it provides no information about 'path' or 'reactions'. It doesn't clarify what path refers to (e.g., a component path) or the structure/format of the reactions object. The schema itself only gives types and nesting, so the description adds no semantic value.

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 'Set x-reactions responder rules' clearly states a specific action (set) and a specific resource (x-reactions responder rules). This distinguishes it from sibling remove_reactions, which is a different operation. However, the meaning of 'x-reactions' and the exact scope of 'responder rules' is not elaborated, so it's clear but not fully self-contained.

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 alternatives, no prerequisites, and no context about typical scenarios. The sibling list includes many set_* tools, but no differentiation or exclusions are mentioned. An agent would have to infer usage from other sources.

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 burden of behavioral disclosure. It only states the basic action and zero-based indexing, but does not disclose whether existing cell content is overwritten, how the optional 'style' parameter affects the cell, whether formulas are affected, or any side effects. This is a significant gap for a mutation tool.

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

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

The description is a single, efficient sentence that front-loads the purpose and the zero-index convention. It wastes no words and is appropriately sized for a tool this simple.

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 'set' operation with an output schema absent and no annotations, the description is mostly adequate but leaves gaps. It does not explain the effect of the 'style' parameter (only the schema lists it), nor does it indicate return behavior or potential overwrites. These omissions could lead to incorrect usage, though the core required parameters (row, col, text) are clearly covered by the 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 100%, so the schema already documents 'row', 'col', 'text', and 'style'. The description adds the zero-index note, which is already present in the schema parameter descriptions. It adds no additional meaning about parameter usage, values, or format. Baseline 3 applies because the schema handles parameter semantics sufficiently.

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

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

The description clearly states the action (设置 = 'set') and the resource ('x-spreadsheet 单元格文本' = 'x-spreadsheet cell text'), and it distinguishes itself by specifying the tab context ('表格搭建 Tab'). While it doesn't explicitly differentiate from sibling tools, the name and verb make the purpose unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or conditions. The intended usage is only implied by the function name and purpose, with no direction on when not to use it or what other tools might be more appropriate.

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 conveys that this is a full template replacement operation in x-spreadsheet format, which implies wholesale overwriting, but it never explicitly states that existing configuration is replaced, whether the operation is reversible, or any prerequisites — significant gaps for a mutation tool with zero annotation coverage.

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 with zero waste; the core purpose and format are front-loaded before the usage note and skill reference. 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 tool accepting a loosely-typed free-form JSON object with no output schema and no annotations, the description relies heavily on an external Skill file (table-building.md) to define the structure. If that file is not injected into the agent's context, the agent cannot reliably construct the x-spreadsheet JSON. The description is adequate only under the assumption that the referenced skill documentation is available.

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% with a basic parameter description ('完整的表格模板 JSON 对象'), so the baseline is 3. The description adds genuine meaning beyond the schema by specifying the x-spreadsheet format and pointing to the Skill file (table-building.md) for the detailed JSON structure, compensating for the fact that tableJson is an unconstrained object (additionalProperties: true) with no internal 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-resource pair ('设置完整的表格模板 JSON') and the format (x-spreadsheet), making the operation unambiguous. It distinguishes itself from siblings like get_table_template (retrieval) and copy_template (template duplication) by clarifying it sets a complete template configuration.

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 a clear usage context: '通常用于从已有模板复制表格配置' (usually used to copy table configuration from an existing template). However, it does not name alternative sibling tools or state exclusions, leaving the boundary against set_full_schema, select_template, and the incremental setters (set_property, set_form_settings) implicit rather than 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?

No annotations are provided, so the description carries the full burden. It discloses only that it mutates the x-validator array, but not how — whether it appends, whether existing validators at the path are retained or replaced, what happens on duplicate rules, or whether any permission is required. For a mutating tool with zero annotation coverage, this is a meaningful disclosure 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, efficient sentence that is front-loaded with the core verb and target. No wasted words. However, it is so brief that it sacrifices informative content for brevity.

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 2-param mutation tool with no annotations and no output schema, the description is thin. It lacks usage guidance, behavioral detail, and any clarification of the undocumented 'path' parameter. An agent calling this correctly must infer semantics that should be 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?

Schema coverage is 50% and the description adds no parameter information at all. The 'rule' parameter has an example in the schema itself, so the description provides no added value there, and 'path' is completely undocumented in both the description and the schema. The description does nothing to compensate for the missing path 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?

States a specific verb (添加/add) and resource (校验规则到 x-validator 数组). It identifies the exact target collection ('x-validator array') and is implicitly distinguishable from its paired sibling remove_validator since adding vs removing are opposite operations. Loses a point because it doesn't explicitly state the add is a push/append operation nor name the sibling.

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

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

No when-to-use context, no prerequisites (e.g., whether the component/path must already exist before adding a validator), and no mention of the obviously related alternative remove_validator. An agent has no guidance on ordering with respect to other component-operations in the sibling 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'update', implying mutation, but doesn't disclose side effects, error behavior, or whether the formula must already exist. No interpretation of response or failure modes is given.

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 single sentence is concise and front-loaded, stating the essential action and object. However, it is under-specified; it lacks structure beyond the bare statement, so it doesn't earn a 5 but is not verbose.

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?

This is a mutation tool with five parameters and no output schema, yet the description only covers the ID. It is highly incomplete—an agent has no information about the remaining parameters' purposes, the expected response, or any constraints. The tool is practically unusable without external knowledge.

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 provides no parameter details beyond the ID mention in the text. The schema has five parameters (id, title, variables, expression, writeFormValue) with no explanations, and the description adds no semantic value for the other four.

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

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

The description clearly states the action (update) and the resource (formula), and specifies the key identifier (ID). It differentiates from siblings like add_formula, list_formulas, and remove_formula by explicitly noting 'update existing'.

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

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

No guidance is given on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., formula must exist), scenarios where updating is preferred over adding/removing, or any exclusions. An agent is left without routing information.

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