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

No annotations are provided, so the description must carry full burden. It mentions clearing cache and restoring state but does not disclose side effects, whether it is destructive, or prerequisites. For example, it doesn't say if it affects all parameters or requires certain permissions. This leaves significant gaps.

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

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

The description is short and front-loaded with the primary action. The inclusion of an Args section adds structure, though it is not standard for MCP descriptions. Overall, it gets to the point with minimal fluff.

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 an output schema exists (not shown), the description does not explain the 'temporary parameter value cache' concept or what happens after clearing. It lacks details on behavior, error conditions, or behavioral impact. Given the tool's complexity (mutation related to parameter state), the description is insufficient for full understanding.

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%, meaning the description does not explain the parameter. The Args section lists 'model_uid' but provides no additional definition, type, or format beyond the schema. The description adds minimal value for 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 action: clearing temporary parameter value cache sent to the model and restoring state. It uses a specific verb ('清除' - clear) and resource ('临时参数值缓存' - temporary parameter value cache). It also mentions pairing with SetParameterValues, which distinguishes its role among siblings, though not fully differentiating from all tools.

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

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

The description says it is used with SetParameterValues, providing context for when to use it. However, it does not explicitly state when not to use it or mention alternatives like cubism_get_parameter_values or cubism_edit. The guidance is implied but lacks exclusions.

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

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

No annotations provided, so description carries full burden. It discloses automatic handling of EditBegin/EditEnd, which is useful transactional behavior. However, it does not mention other traits such as effects on model state, error conditions, or required permissions. Adequate but minimal.

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 sentences plus a structured Args list. No filler or redundancy, every sentence is meaningful.

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 presence of an output schema (not needed to describe), the tool is fairly complete. It explains the purpose, transaction handling, and parameter semantics. Could mention the implicit current document context, but overall adequate for a simple edit tool.

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

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

Schema coverage is 0%, but the description adds significant meaning: action is an API name with examples, and params is an object that automatically receives ModelUID. This helps the agent understand parameter usage beyond the schema's bare types.

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 'execute edit operation' and automatically handles EditBegin/EditEnd, which indicates a single edit operation. Combined with the action enum listing specific APIs like AddParameter, EditPart, etc., the verb and resource are clear. However, the description alone is slightly generic and could be more specific, hence a 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?

There is no guidance on when to use this tool versus alternatives like cubism_edit_batch or other sibling tools. The description does not mention prerequisites, context, or exclusions, leaving the agent without clear selection criteria.

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

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

The description reveals that operations are executed within a transaction (atomicity). However, it does not disclose failure behavior, rollback, permissions, or side effects. With no annotations, the description carries the full burden and provides only partial 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 extremely concise: two lines covering purpose and parameter structure. No unnecessary words, front-loaded with the key idea, and every sentence adds 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?

Given the batch nature and nested objects, the description adequately covers the parameter structure and transaction behavior. The output schema exists, so return values are covered. However, it could provide more context about error handling or transaction rollback to be 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?

The schema has 0% description coverage, but the description adds crucial semantics: 'actions: [{action, params}] array, action is edit API name, params is its parameter object'. This provides the structure and meaning of each element, which the schema (array of objects with additionalProperties) lacks entirely.

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 'batch execute multiple edit operations' with 'within the same EditBegin/EditEnd transaction', which defines its purpose as performing multiple edits atomically. It distinguishes from the sibling tool 'cubism_edit' by implying batch vs single operation.

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 multiple edits but does not explicitly state when to use versus alternatives like 'cubism_edit'. It lacks explicit when-to-use/when-not-to-use guidance or mention of 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 bears full burden for transparency. It correctly identifies the tool as a read-only getter by stating '获取' and listing return values. However, it does not mention potential failure modes or whether a model must be open, leaving some behavioral 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 extremely concise (two sentences) and places the core action first. Every word serves a purpose, with no unnecessary 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?

Given the tool's simplicity and the presence of an output schema, the description provides sufficient information: it states the resource ('Editor 当前的编辑模式') and the possible return values. However, it could mention that the Editor is a Cubism Editor context, which is assumed but not explicit.

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

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

The tool has zero parameters, so the baseline score is 4 per rubric. The description adds no parameter-level detail, but none is needed since the input schema is complete and empty.

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 that the tool retrieves the current edit mode and lists possible return values (Physics/Modeling/Animation/ModelingMeshEdit/FormAnimation). However, it does not explicitly differentiate from similar sibling tools like cubism_status, leaving some 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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, context, or exclusions, which limits its usefulness for an AI agent deciding which tool to invoke.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose behavioral traits such as whether the operation is read-only, error handling, or performance implications. The name implies read-only, but the description provides no explicit confirmation.

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 (one sentence plus Args list), but given the low schema coverage, it is under-informative. It earns basic marks for being brief, but does not provide adequate detail for an agent to use the tool effectively.

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 a single parameter and an output schema exists, which may document return values. However, the description does not mention the output or provide context about the deformer structure tree. It is adequate for a simple getter but lacks completeness.

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

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

Schema description coverage is 0%, and the description only lists the parameter name and a Chinese translation ('模型 UID'). It adds minimal semantic context beyond the schema's title 'Model Uid', lacking explanation of how to obtain the UID or any constraints.

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 it gets the model's deformer structure tree. It is a specific verb+resource pair, but it does not differentiate from sibling tools like cubism_get_parameter_structure or cubism_get_part_structure, which likely return related but different hierarchies.

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. The description simply states what it does without any context about prerequisites, when not to use, or how it fits with other 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 full burden. It states it gets '详细信息' but does not disclose behavioral traits like idempotency, side effects, or access requirements. The presence of an output schema mitigates the lack of return description, but overall transparency is minimal.

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, with a single sentence front-loading the purpose, followed by a clear Args section. No unnecessary words.

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

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

Given the presence of an output schema, the description is sufficient for a simple retrieval tool with one parameter. It explains the parameter source and the core action, leaving details of the output to 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 0%, but the description adds meaning by explaining 'document_uid' as '文档 UID' and its source from cubism_get_documents. For a single parameter, this adds useful context, though it does not specify format or constraints.

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 '获取单个文档的详细信息' (get detailed information of a single document), providing a specific verb and resource. It implicitly distinguishes from the list tool cubism_get_documents by specifying '单个' (single), but does not explicitly contrast with other 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?

The description only hints that document_uid can be obtained from cubism_get_documents, but lacks explicit guidance on when to use this tool versus alternatives, no when-not or exclusion criteria.

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 the return structure (arrays per type, empty arrays if missing) and that it returns the globally open list. However, it does not mention edge cases (e.g., no documents open) or performance implications.

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, with three sentences that are front-loaded with the main purpose. Every sentence provides necessary information without redundancy.

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

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

Given the tool has no input parameters and an output schema exists, the description adequately explains the return format (three arrays) and scope (global list). It is complete for this simple tool.

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

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

The input schema has zero parameters with 100% coverage. The description adds value by explaining the tool's behavior and output structure, which is sufficient for a parameterless tool.

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 it lists all currently open documents in the Editor, categorized by type (PhysicsDocuments, ModelingDocuments, AnimationDocuments). It distinguishes from siblings like cubism_get_document by noting that no model_uid is needed and it returns the global 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?

The description implies when to use (to get the list of open documents) and contrasts with tools that require a model_uid. It provides clear context but lacks explicit exclusions or 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?

No annotations provided, so description carries burden. It identifies a read operation but does not disclose error conditions (e.g., no model open) or 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?

Single sentence with no fluff. Front-loaded and directly conveys purpose.

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

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

Tool has no parameters and has an output schema (though not shown). Description is complete enough for a simple getter, but could mention output format or relationship to sibling tools.

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

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

No parameters; schema coverage is 100% trivial. Baseline score of 4 applies, and description does not need to add parameter info.

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 it gets the model UID from Cubism Editor. The verb 'get' and resource 'model UID' are specific, and the tool is distinct from siblings like cubism_get_parameters.

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 cubism_get_parameter_values. The simple no-parameter design implies straightforward usage, but explicit context is missing.

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 mentions that data structures vary by Type, but does not cover side effects (e.g., read-only nature), permissions, error conditions, or other behaviors. This is insufficient for safe invocation.

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 (one line plus Args list) and well-structured in a docstring format. It is appropriately sized and front-loaded, though it could be more concise by omitting the redundant Args section since the schema already lists parameters.

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 an output schema exists, the description need not detail return values. However, it lacks completeness: no examples, no explanation of the object types, no mention of possible errors or versioning. For a simple tool with two required params, it is adequate but not thorough.

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%, meaning the description does not add meaning beyond parameter names. The Args section merely restates the names ('模型 UID', '对象 ID') without explaining constraints, formats, or sources. This fails to compensate for the lack of schema descriptions.

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 (获取/get) and resource (对象/object), and explicitly notes that the returned data structure varies by Type (ArtMesh, Part, etc.). This distinguishes it from sibling tools like cubism_get_parameters or cubism_get_part_structure, which are more specific.

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 explicit guidance on when to use this tool versus alternatives. It does not mention when not to use it, prerequisites, or suggest other tools for specific needs. Usage is only implied, leaving the agent to infer.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It merely states the operation (getting a list) without mentioning side effects, permissions, rate limits, or read-only nature. For a read operation, this is a minimal 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 very short (two sentences) and front-loaded. It contains no unnecessary words, but the brevity limits its utility. It is concise but could be more informative without losing 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 tool with one parameter and an output schema (which exists but is not shown), the description is minimally adequate. It specifies the output contains group UID and names, but lacks details on format or structure. Given the output schema, the description does not need to fully specify return values.

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 add meaning beyond the schema. It only repeats 'model_uid: 模型 UID', which adds no additional detail beyond the parameter name and type. This does not compensate for the lack of schema descriptions.

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 retrieves a list of parameter groups (group UID and names) for a model, using the specific verb '获取'. This distinguishes it from siblings like cubism_get_parameters (parameters) and cubism_get_parameter_structure (structure).

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. The description lacks context about prerequisites, use cases, or exclusion conditions, leaving the agent to infer appropriate usage from the tool 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 bears full burden. It correctly implies a read operation ('获取') and describes the data returned, but does not explicitly state read-only behavior, authorization needs, or side effects. Given the output schema exists, the description is sufficient but lacks explicit safety traits.

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: one sentence for purpose, one for differentiation, one bullet for the parameter. No wasted words, front-loaded with the core action.

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 an output schema, it does not need to describe return values. The description covers input parameter semantics and differentiation from a key sibling. It could mention usage contexts like when detailed parameter structure is needed, but is mostly complete.

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

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

Schema coverage is 0% (no parameter descriptions in schema), so the description compensates by adding an Args section explaining model_uid as '模型 UID'. This adds meaning beyond the bare schema. With only one parameter and clear explanation, it helps the agent.

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 it gets detailed metadata of model parameters including type, range, default, key points, blend shapes, loops. It explicitly distinguishes itself from cubism_get_parameter_values by noting it returns additional structural information like parameter names, types, ranges, GroupUID.

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 directly compares with cubism_get_parameter_values, clearly indicating when to use this tool for richer metadata. However, it does not explicitly state when not to use it or mention other 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?

No annotations are provided, so the description carries the full burden. It merely states what is returned but does not disclose behavioral traits such as read-only nature, cost, side effects, or authentication requirements. The description is too brief for a tool with no annotations.

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

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

The description is extremely concise with two sentences, front-loading the purpose immediately. No redundant 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 that an output schema exists (so return values need not be described), and there is only one parameter, the description is sufficiently complete. It could mention that it is a read operation, but overall it covers the essentials.

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 is only one parameter, and the schema description coverage is 0%. The description adds value by explaining what model_uid is and how to obtain it (via cubism_get_model_uid), going beyond the schema's generic 'Model Uid' title.

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 that the tool retrieves the complete parameter structure tree, including groups and parameters with Min/Default/Max/KeyValues. This distinguishes it from sibling tools like cubism_get_parameters or cubism_get_parameter_groups that likely return subsets.

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 explicitly state when to use this tool versus alternatives. It mentions a prerequisite (model_uid via cubism_get_model_uid) but lacks guidance on when to choose this over siblings like cubism_get_part_structure or cubism_get_deformer_structure.

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?

无注解，描述承担全责。说明是只读操作、无需事务，未暗示任何副作用，行为透明充分。

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?

模式描述覆盖率为0%，描述对每个参数提供了含义：model_uid通过cubism_get_model_uid获取，ids可选且解释省略时的行为，增加了模式未提供的价值。

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?

描述明确使用动词'获取'和资源'参数值'，清晰表达功能。与兄弟工具cubism_set_parameter_values和cubism_clear_parameter_values区分开，指明不指定ids则返回全部参数。

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?

明确说明是轻量级读取操作，无需EditBegin/EditEnd事务，提供了使用上下文。虽未明确排除替代方案，但已足够指导何时使用。

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 provided, and the description does not disclose any behavioral traits beyond the basic function. No mention of read-only nature, auth requirements, or 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?

Description is short and front-loaded with the main purpose. It efficiently conveys key information without extraneous 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?

Given the presence of an output schema, the description is minimally complete. It lists included types but could be more specific about the tree structure or edge cases.

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 description briefly explains the single parameter ('model_uid: 模型 UID'), which adds some meaning since the input schema provides no description (0% coverage). However, it lacks depth (e.g., format, examples).

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 clearly states verb ('获取/get') and resource ('部件结构树/part structure tree'), and lists included types to distinguish from sibling tools like cubism_get_deformer_structure.

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?

Description only explains what the tool does without specifying when to use it vs. alternatives or when not to use it. Usage context 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?

Without annotations, the description carries the full burden. It discloses that the tool retrieves a list of IDs from the Editor selection, implying a read-only query. However, it does not elaborate on edge cases (e.g., empty selection), permissions, or side effects. It is adequate but not detailed.

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 concise—two sentences covering purpose and parameter. It is front-loaded with the core action. Every sentence is useful, but the structure could be improved by separating the parameter description more clearly.

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 existence of an output schema (not shown), the description need not detail return values. However, it lacks usage examples, error handling notes, or contextual cues for the Editor state. It is minimally complete for a simple getter but leaves gaps for confident 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 minimal explanation for the parameter 'model_uid' (Chinese: '模型 UID'). This provides a basic semantic cue beyond the schema's title, but it does not specify the UID's source or format. The added value is marginal.

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 it gets the list of object IDs currently selected in the Editor. The verb '获取' (get) and resource 'selected object IDs' are specific. Among siblings, it uniquely targets the selection state, differentiating it from other getters.

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. There is no mention of prerequisites, context, or when-not-to-use scenarios. The description simply states functionality without comparative or contextual 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 provided, but description fully compensates by disclosing buffered writes, delay in physics/animation models, and the clear behavior. No contradictions.

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

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

Front-loaded with purpose, then usage details. Each sentence adds value. Could be slightly more concise, but the example is helpful.

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?

Covers input, behavior, and usage. Output is not described, but an output schema exists. For a mutation 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?

Despite 0% schema coverage, description explains both parameters clearly: model_uid as string, parameters as array of objects with Id and Value, and provides an example. This adds significant meaning 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?

Clearly states the verb (设置) and resource (参数值 of a model). Mentions lightweight write without EditBegin/EditEnd transactions, which distinguishes it from cubism_edit tools. However, it could explicitly name alternatives for clarity.

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 context: lightweight write, no transaction needed, temporary buffer with possible delay, and suggests ClearParameterValues for clearing. Lacks explicit when-not-to-use but sufficient for agent to choose correctly.

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?

Discloses return of specific guidance on failure. But no description of success behavior (e.g., returns connection status). No annotations provide additional 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?

Single sentence, perfectly concise, front-loaded with purpose. No wasted words.

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

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

For a simple zero-parameter tool with output schema, description covers purpose and failure guidance. Minor gap: success return not described, but output schema may cover it.

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?

No parameters, so schema coverage is 100%. Description does not add param info, but none needed. Baseline for zero params is 4.

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

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

Clearly states the tool checks connection and authorization status with Cubism Editor. The verb '检查' and resource '连接及授权状态' are specific. Sibling tools do not mention connection/auth, so it's distinct.

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 explicit when-to-use or alternatives. However, from sibling list, it's the only tool for this purpose, so usage is implied. No guidance on when not to use.

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