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 basic add action and does not disclose preconditions (e.g., a document must be open and the target transition must already exist), whether the change is destructive or reversible, or whether a save is required afterward. It is not misleading, but it is far too thin 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 single sentence is front-loaded with the verb and contains no wasted words. However, the brevity is closer to under-specification than disciplined conciseness, since the sentence omits the usage, precondition, and parameter context the tool 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?

This is a complex mutation tool with a large schema (14+ $defs, polymorphic value types) and zero annotations, yet the description is one sentence. It does not explain item types, how 'value' varies by 'type', or preconditions. The output schema covers return values, but the missing behavioral and semantic context makes the description inadequate for reliable 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 only hints at the 'item' parameter via '类型化关键帧轨道项' and says nothing about the 'name' parameter. The TransitionItem's polymorphic 'type' and 'value' fields, whose shape varies across 13 possible value types, are entirely unexplained, leaving the agent to guess at valid combinations.

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 (添加/add), a resource (Transition), and an object (类型化关键帧轨道项/typed keyframe track item), which distinguishes it from siblings like fgui_update_transition_item and fgui_remove_transition_item by the add-vs-update/remove verb. However, the term 'typed keyframe track item' is unexplained jargon, leaving some ambiguity about what exactly is being added.

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 zero guidance on when to use this tool versus its close siblings fgui_upsert_transition, fgui_update_transition_item, and fgui_remove_transition_item. An agent cannot tell whether this tool requires an existing transition, whether it can create one, or when 'add' is preferred over 'upsert' or 'update'.

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 discloses the state image order, a useful behavioral detail, but omits key aspects such as whether the tool modifies the active document, requires an open package, or has side effects like opening the created button. Minimal transparency for a creation 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, concise sentence that immediately communicates the core purpose and a key detail. There is no wasted wording, and it is appropriately 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?

Despite having an output schema, the tool is complex (16 parameters, no parameter descriptions, no annotations). The one-sentence description is far from complete—it does not explain typical usage scenarios, parameter interactions, or potential pitfalls. It is minimally viable but with significant gaps for an agent to invoke the tool correctly.

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

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

Schema description coverage is 0%, and the description provides no explanation of any of the 16 parameters. While some parameter names are self-explanatory, many (e.g., as_list_item, create_relations, open_after_create) are ambiguous without further context. The description completely 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 tool creates a standard FairyGUI Button component with a specific verb-resource pair. The mention of state image order also distinguishes it from generic component creation or other sibling tools like fgui_create_component.

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

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

The description implies when to use this tool (to create a standard button), but it does not explicitly discuss alternatives or when not to use it. No exclusions or references to sibling tools are provided, so guidance is limited to what is already obvious 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 provided, the description carries the transparency burden. It discloses key default behaviors: '默认打开但不保存' (opens by default but does not save) and '重名时默认拒绝' (duplicate names are rejected by default), which go beyond what the schema reveals. However, it omits other side effects such as whether the component is added to the active document or requires prior project setup.

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 entire description is one concise sentence that front-loads the primary action and uses semicolons to add default behaviors. Every clause adds meaningful information without redundancy, making it highly efficient for the agent 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?

Despite having an output schema, the tool has 10 parameters and no annotation support, and the description only explains a subset of behaviors. It does not cover packaging, folder structure, exported flags, or extension relationships, making it incomplete for fully autonomous invocation. The complexity of the tool demands a richer description.

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 zero schema description coverage, so the description must compensate for the 10 parameters. It only indirectly references package_name ('在指定包中'), open_after_create ('默认打开'), and auto_rename/naming conflict ('重名时默认拒绝'). Parameters like width, height, exported, folder_path, extension_id, and create_folders are entirely unaddressed, leaving significant ambiguity.

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 a new component document in a specified package. The verb '新建' (create) plus resource '组件文档' (component document) and scope '在指定包中' (in specified package) makes the purpose unambiguous and distinguishes it from sibling tools like fgui_create_button or fgui_insert_object.

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 this tool is for creating components but does not explicitly contrast it with alternatives such as fgui_create_button or fgui_open_document. There is no when-not-to-use guidance or mention of prerequisites, leaving users to infer the appropriate context from the tool name and siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'create or replace' but does not explain side effects, whether it overwrites existing resources, if it requires an active document, or how conflicts are handled (though conflict_policy exists in schema). No mention of mutability, reversibility, or error conditions. 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 sentence with no fluff, front-loading the core purpose. It is concise and to the point, but the brevity comes at the cost of missing crucial details. Still, it earns a 4 for being well-structured and 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?

Given the tool has 12 parameters, zero parameter descriptions in the schema, no annotations, and no explanation of return values or outputs, the description is far from complete. It provides only a high-level summary, leaving agents without essential information to invoke the tool correctly. No guidance on required parameters, defaults, or use 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?

Schema description coverage is 0%, so the description must compensate, but it only references 'ordered absolute image paths' which maps to frame_paths. It does not explain fps, swing, exported, conflict_policy, folder_path, or any of the other 11 parameters. An agent would have to guess the meaning and valid values for most parameters, making this tool difficult to call correctly.

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/replace) and resource (MovieClip), and specifies the key input (ordered absolute image paths). It distinguishes from fgui_update_movieclip by mentioning replacement, but does not explicitly contrast with siblings like fgui_get_movieclip or fgui_remove_movieclip, so it's 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 on when to use this tool versus alternatives like fgui_update_movieclip. It does not mention prerequisites (e.g., open document), when creation vs replacement is appropriate, or any conditions that would make this tool the right choice. The description only states what it does, not when to use it.

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 transparently states the destructive nature (discarding all unsaved modifications) and the reload action. It does not explicitly warn about irreversibility, but 'discard' strongly implies it.

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, well-structured sentence that immediately states the verb and object, with no unnecessary words or repetition.

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 (discard and reload), the description fully conveys the behavior. Since an output schema exists, no return-value details are needed, and the one-sentence explanation is sufficient.

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 described action is complete as-is. With an empty schema, no additional parameter meaning is needed, and the baseline for 0-parameter tools is 4.

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

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

The description uses a specific verb ('discard') and clearly identifies the resource ('all unsaved modifications of the current document') and the action ('reload the disk version'). This distinguishes it from siblings like fgui_save_document and fgui_undo.

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 context is clear: use this tool when you want to discard all unsaved changes and reload the saved version. It does not explicitly mention alternatives or when not to use it, but the intent is understandable 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?

With no annotations, the description carries the transparency burden. It clearly uses '读取' (read), indicating a non-destructive operation, which is a key behavioral trait. However, it does not disclose what happens if no document is active, whether any side effects occur, or error behavior. This is adequate for a simple getter but not rich.

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 in Chinese that is front-loaded with the verb '读取' and states exactly what is read. Every word earns its place 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?

For a getter with no parameters and an output schema present, the description fully covers the tool's purpose. The output schema presumably details the return structure, so the description need not repeat it. The description is sufficient for an AI agent to understand what this tool does.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameter semantics, and the schema correctly shows no properties. The description adds no parameter-related confusion.

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 reads the current active document, its modification status, and selection count. This is a specific verb (read) with a clear resource, and it distinguishes from siblings like fgui_get_tree (gets tree structure) and fgui_get_history (gets history).

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 when you need the current document's state, but it does not explicitly state when to use this tool versus alternatives or provide exclusions. There is no mention of prerequisites (e.g., an open document) or when not to use it, so guidance is only implicit.

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 it reads two types of state, implying a read-only operation, but does not explicitly confirm safety, side effects, error conditions, or what the returned data actually contains. More behavioral context would be valuable.

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 leads with the verb. No wasted words, and it is front-loaded with the 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?

For a zero-parameter read tool with an output schema, this is mostly sufficient. However, it doesn't explicitly state that it is non-destructive or explain how it relates to the undo/redo workflow with siblings. Given the lack of annotations, a bit more context would improve 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?

The tool has zero parameters, so the schema coverage is effectively complete. The baseline of 4 for no parameters applies, and the description doesn't need to add 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 uses the specific verb '读取' (read) and clearly identifies the resources being read: the Agent property transaction stack and FairyGUI native undo state. While it doesn't explicitly contrast with sibling undo/redo tools, the name and resource references make its purpose clear enough.

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 fgui_undo/fgui_redo or other siblings. There are no alternatives, exclusions, or contextual triggers mentioned.

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 must carry the disclosure burden. It clearly indicates a read operation via '读取', implying non-destructive behavior, but does not explicitly state side effects, error handling, or return format. It adds context about the specific attributes read, which is some behavioral disclosure, but not exhaustive.

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, highly concise and front-loaded with the action. It covers the core purpose efficiently without waste, though it provides no additional helpful context.

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 optional parameters and zero schema descriptions, the description is insufficient for an agent to correctly invoke the tool. Even though an output schema exists, the description does not describe the expected input selection or return behavior, leaving the tool incomplete for practical use.

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 for its parameters (url, item_name, item_path, package_name), and the description does not explain any of them. An agent has no clue how to populate these parameters to target a specific MovieClip, making this a significant gap.

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

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

The description states a clear verb ('读取' = read) and resource (MovieClip), and lists the specific fields to read (frame, FPS, Swing, RepeatDelay). This makes it distinct from related tools like fgui_update_movieclip or fgui_create_movieclip, 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 provides no guidance on when to use this tool versus alternatives. It does not mention other getter tools (e.g., fgui_get_text_style) or specify scenarios where this tool is appropriate, leaving the agent to infer 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?

There are no annotations, so the description carries the behavioral disclosure burden. '获取' and 'Returns' indicate a read-only query, and the description does state the key return content. However, it does not disclose failure behavior, dependencies, or whether the package must already be loaded.

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

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

The description is compact and front-loaded with the main purpose, followed by a concise Args/Returns structure. The Args section is slightly redundant with the schema, but there is no padding or irrelevant 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 one-parameter read operation with an output schema, the description is minimally adequate. However, the absence of annotations, lack of usage boundaries, and no mention of package-loading prerequisites or error behavior leave meaningful gaps for an agent selecting among many 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?

Schema description coverage is 0%, so the description must compensate. The Args line 'package_name: 包名称' merely restates the property name and title; it adds no format, identifier convention, examples, or additional 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 states a specific action ('获取') and a specific resource ('指定 UI 包的详细信息'), and adds that the return includes all resource lists. This differentiates it from list-level siblings like fgui_list_packages, though it does not explicitly name any 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 guidance is provided about when to use this tool versus alternatives such as fgui_list_packages or fgui_list_resources. There is also no mention of prerequisites like whether a project or document must be open/loaded before calling it.

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 says 'read' which implies non-mutating, but it does not clarify what data is returned, error conditions, or whether any session state is required.

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 without fluff. However, it is under-specified for a tool with no parameter details, missing valuable information about what constitutes 'project 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?

Although an output schema exists, the description fails to indicate what fields or sections of project information are returned. For a query tool, this is a significant gap; the agent cannot predict the scope of the response.

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

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

The tool has zero parameters, so schema coverage is complete (100%). The description does not need to explain parameter semantics; the baseline of 4 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 action (read) and resource (current FairyGUI project info), but it is vague about what information is included. It does not distinguish this tool from siblings like fgui_status or fgui_get_active_document.

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 about when to use this tool versus alternatives. There is no mention of prerequisites, common use cases, or exclusions.

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

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

No annotations are provided, so the description must carry the behavioral burden. It uses '读取' (read), implying a non-destructive operation, which is a mild safety signal. It does not mention side effects, prerequisites, or error handling, leaving some behavioral uncertainty.

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 with no filler. The first sentence front-loads the core purpose, and the second adds the key usage timing. Every word contributes 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?

The tool is simple with one optional parameter and an output schema (not shown). The description explains what is read and when to call it, but it does not clarify the parameter's role or behavioral details like return structure or prerequisites. This is adequate but leaves notable gaps 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 schema has 0% description coverage for the only parameter, package_name. The description mentions '包级覆盖设置' (package-level override settings), which hints that the parameter is related to a package, but it does not explicitly explain how package_name affects the output or that it is optional. This is insufficient to compensate for the missing schema 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 it reads project publish directory, format, atlas, code generation, and package-level override settings. The verb '读取' (read) and the specific resource set make the purpose clear. It indirectly distinguishes from the sibling fgui_publish by noting this should be called before publishing, but it does not explicitly name alternative 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 explicitly says '发布前应先调用' (should be called before publishing), providing a clear context for when to use the tool. It does not mention when not to use it or suggest alternatives, but the pre-publish guidance is a useful and specific usage directive.

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, but it only says 'read'. It does not disclose how the object is resolved from id/name/path, what happens when no object matches, or whether any side effects occur. The read verb implies non-mutation, but little else is 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 concise sentence with no filler, which is good. However, it is under-specified: it omits parameter semantics and usage context, so the brevity comes at the cost of usefulness.

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?

An output schema exists, so return-value details are not required, but the tool still has three optional object-identification parameters and no annotations. The description does not explain how to select the object or when this tool is appropriate, leaving a meaningful gap 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?

Schema description coverage is 0% and the description does not mention any of the three parameters. object_id, object_name, and object_path are left entirely undocumented, so the agent cannot infer how to target the desired TextField/RichText.

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 read operation on a specific resource ('TextField/RichText 的统一文本样式'), and the get/set contrast with fgui_set_text_style helps distinguish it. However, 'unified text style' is somewhat jargon-heavy and the object-targeting aspect is left to 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?

No guidance is given about when to use this tool versus alternatives such as fgui_set_text_style or other inspection tools. The read intent is implied, but there are no explicit conditions, prerequisites, or exclusions.

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

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

With no annotations, the description carries the behavioral burden. '读取' signals that the operation is read-only, and '当前组件' scopes it, but nothing is said about missing-name behavior, active-document 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?

The description is a single front-loaded sentence with no filler or redundant restatement of the tool name. Every word contributes to purpose, scope, or lookup mode.

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?

Although the tool is simple and has an output schema, the description leaves 'current component' undefined and omits when to use the tool and what happens if the transition does not exist. It is minimally viable but not 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 no description for the required 'name' parameter (0% coverage), but the description's '按名称' explicitly ties the parameter to the transition's name within the current component. For a single obvious string parameter, this is sufficient added meaning.

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

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

The description states a specific verb ('读取'), a concrete resource ('当前组件的一个 Transition'), and the selection mode ('按名称'). This clearly distinguishes it from the sibling fgui_list_transitions, which lists transitions rather than returning a single named one.

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 about when to prefer this tool over list/upsert/remove transition alternatives, and no prerequisites such as requiring a current component. The intended usage is only weakly implied by the verb '读取'.

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 of behavior disclosure. The term 'read' implies a non-destructive operation, and the advice to get stable IDs before modifying adds context. However, it doesn't detail any potential side effects or limitations, so transparency is moderate.

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 two clauses, providing the core purpose and a usage tip without any wasted words. It is front-loaded 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 tool is simple, with one parameter and an output schema provided. The description covers the what and when, and the output schema handles return values. The only gap is the undocumented max_depth parameter, but the overall context is sufficient for a basic read 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 single parameter max_depth has no description in the schema (0% coverage) and the tool description does not mention it, leaving its semantics unexplained beyond the name. 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 clearly states the tool reads the current component object tree, using the specific verb 'read' and a distinct resource. This differentiates it from mutation tools like fgui_insert_object and fgui_remove_object.

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 notes that this should be used before modifications to obtain stable object IDs or paths, providing clear usage context. It doesn't explicitly exclude other tools but indicates the intended timing.

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 does disclose that this is a disk write operation and mentions the conflict policy (reject, auto-rename, replace), which conveys that it may overwrite or rename existing files. However, it does not discuss side effects such as what happens to existing fonts, whether the operation is reversible, or any permission requirements. The transparency is partial but 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, efficient sentence that front-loads the primary action and then adds the key caveat about disk writes and conflict handling. There is no redundancy or filler, making it appropriately concise and well structured.

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 8 parameters with zero schema description coverage and no annotations, the description is insufficient for an agent to call it correctly. It fails to explain most parameter semantics, does not mention any prerequisites (e.g., an open document or package), and lacks information about return behavior. The description is far from complete for the tool's 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 compensate. It explains that source_path is an absolute local path and hints at conflict_policy via the rejection/rename/replace mention. However, it does not clarify the other six parameters (package_name, exported, folder_path, resource_name, create_folders, timeout_seconds), leaving the agent without sufficient understanding of their meaning or defaults.

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: importing a font from an absolute local path. It specifies the resource type (font) and the source location, distinguishing it from sibling import tools like import_image and import_sound. The verb 'import' and resource 'font' are explicit 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?

The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention prerequisites, conditions, or exclusions. The only implied usage is that it is for fonts, which is already obvious from the name. There is no discussion of when a different import tool would 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?

With no annotations provided, the description carries the full burden. It explicitly states 'this is a disk write operation' and describes the conflict handling modes (reject, auto-rename, replace). This provides useful behavioral context beyond the schema, though it could mention permissions or reversibility.

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 starts with the core action and adds key context. It is concise, front-loaded, and contains no 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?

Despite being a tool with 8 parameters and no annotations, the description only covers the source path and conflict policy. It omits other significant parameters like folder_path, create_folders, resource_name, and timeout_seconds. An output schema exists, but the description leaves too much to discover through parameter names 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 description adds meaning to two parameters: 'source_path' (absolute local path) and 'conflict_policy' (reject, auto-rename, replace). However, with 8 parameters and 0% schema description coverage, the other six parameters (exported, folder_path, resource_name, create_folders, timeout_seconds) are left unexplained. The description partially compensates but not fully.

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 ('import image'), the resource type ('image'), and the source ('absolute local path'). It also declares a disk write operation, which distinguishes it from read-only sibling tools like fgui_get_tree or fgui_status. This 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?

The description implies when to use this tool (when importing an image from a local path). It clearly sets the context but does not explicitly state when not to use it or mention alternative tools. Since the context is clear and no exclusions are given, a 4 is 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states that this operation is a disk write ('属于磁盘写入') and that it supports replacing same-name sounds, which are important side-effect and mutation cues. However, it does not detail reversibility, permission needs, or the exact overwrite behavior across conflict policies.

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

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

The description is compact and front-loaded: it states the action and resource first, then adds behavioral notes about replacement and disk writing. Every clause contributes information without redundancy or filler.

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

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

Given 8 parameters, 0% schema description coverage, and no annotations, this one-line description is insufficient for reliable invocation. It omits how required and optional parameters interact, what the conflict policy semantics are, and what happens to existing resources. The output schema may cover return values, but the input side remains under-specified.

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 implicitly clarifies 'source_path' as an absolute local path and hints at name-replacement behavior. It does not explain key parameters such as package_name, folder_path, resource_name, exported, create_folders, conflict_policy, or timeout_seconds, leaving most of the 8-parameter surface undocumented.

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

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

The description clearly states a specific action and resource: importing a sound resource from an absolute local path. It also differentiates from sibling import tools like fgui_import_image and fgui_import_font by specifying 'sound'. The additional mention of replacing same-name sounds gives further functional 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?

The description gives clear context: use this tool to import a sound resource from a local absolute path. It does not explicitly exclude alternatives or name sibling tools, but the resource type and import semantics make the intended use reasonably unambiguous.

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 reveals two key behaviors: the operation is non-persistent (not saved) and is not undoable through the Agent property transaction stack. This is valuable beyond the tool name and schema, although it does not mention return values or 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 a single sentence that packs two essential caveats (no save, no undo via property stack) without excessive verbosity. It is concise, front-loaded, and every word contributes meaningful 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?

The tool has 5 parameters and an output schema, but the description only covers core behavior and key caveats. It omits parameter semantics, where the insertion occurs, and prerequisites (e.g., active document). While the output schema covers return values, the description is not fully complete for a tool with this complexity and 0% schema coverage.

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 meanings. It only hints at the 'url' parameter via 'ui:// resource' and leaves x, y, name, and insert_index unexplained. The description adds little value over the raw schema, resulting in a poor score for parameter semantics.

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

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

The description clearly states the tool's function: inserting an existing ui:// resource. It also distinguishes itself from save operations by explicitly noting it does not save, and the tool name and sibling fgui_remove_object make the insert/remove contrast clear.

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 the tool (to insert an existing ui:// resource) and provides important constraints: it does not save, so a separate save tool is needed for persistence; and structural operations are not undoable via the Agent property transaction stack, warning against relying on undo. It does not explicitly name alternative tools, but the save and undo caveats offer practical usage 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 available, the description carries the full burden of behavioral disclosure. It states the core action (list resources) and the filtering capability, but does not explicitly mention that it is read-only, nor does it describe potential errors (e.g., package not found) or any limitations. The behavior is predictable 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, concise sentence that front-loads the primary action and resource, with the filtering capability added at the end. Every word contributes meaning, and there is no redundant or extraneous 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?

The tool is simple with only two parameters and an output schema, but the description lacks context about the broader workflow (e.g., that this is a read-only inspection step before editing) and does not explain the valid values for item_type or the structure of the output. It covers the basics but leaves gaps for an agent to fully understand how and when to invoke 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?

The schema descriptions coverage is 0%, so the description must compensate. It does so by indicating that 'package_name' refers to the specified package ('指定包') and that 'item_type' is used for filtering by FairyGUI resource type. This adds semantic meaning beyond the raw property names, though it does not enumerate valid item_type values.

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 '列出' (list) and the resource '指定包中的资源' (resources in the specified package), distinguishing it from sibling tools like fgui_list_packages which lists packages. It also mentions the optional filtering by resource type, making the purpose 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?

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. It neither names sibling tools for comparison nor explains typical use cases, leaving the agent to infer when listing is 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 burden of behavioral disclosure. It states the action 'list' which inherently implies a read-only query, but it does not disclose additional behavioral traits such as side effects, error conditions, or performance implications. The description is minimal but 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 that immediately states the tool's purpose without any redundant information. It is well-structured 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 zero-parameter list tool with an output schema, the description is sufficiently complete. It clearly defines the scope (current project) and the result (all packages). The presence of an output schema covers return value details, and there is no additional complexity requiring more 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, so the baseline of 4 applies. There is nothing to explain beyond the schema, and the description correctly omits parameter details.

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 resource '全部包' (all packages) in the current FairyGUI project. It clearly distinguishes this tool from siblings like fgui_list_items (list items) and fgui_get_project (get project info).

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 when the agent needs to enumerate available packages in the current project, but it does not explicitly state when to use it versus alternatives or mention any exclusions. There is no explicit guidance on selecting this over related 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 behavioral burden. It states that the tool lists resources and returns a resource list, which is sufficient for a simple read operation, but it does not disclose sorting, pagination, error behavior, or side effects. Nothing in the description contradicts expected 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 short and front-loaded with the main purpose, followed by compact argument definitions and a return note. It is appropriately sized, though the argument bullets largely restate schema names rather than adding deep explanation.

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 two-parameter list tool with an output schema available, the description is mostly complete: it names the package, the optional filter, and the return type. Minor gaps are the lack of usage context versus sibling tools and no mention of what happens when a package does not exist.

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 add meaning: package_name is clarified as 'package name', and resource_type gains explicit allowed values (component/image/font/folder) plus the behavior of omitting it to list all resources. This goes meaningfully beyond the bare 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 tool's action ('列出包内的资源' — list resources in a package) and its scope. It is easy to understand what the tool does, though it does not explicitly distinguish itself from siblings like fgui_list_items or fgui_list_packages.

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, and no exclusions or prerequisites are mentioned. The optional resource_type filter is documented, but there is no context about choosing between this and sibling list-type 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 disclosure burden. It transparently implies a read-only operation and scopes the behavior to the current component, but it does not state prerequisites (e.g., open component) or edge-case behavior. The output schema mitigates return-shape ambiguity, and a list/read operation is low-risk.

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 no filler. Every phrase earns its place: '全部' clarifies scope, '当前组件' identifies context, and '类型化关键帧' states what is included.

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

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

For a parameterless list operation with an output schema, this description is complete. The agent knows the operation is read-only, which component it applies to, and what is returned, with no missing parameters or prerequisites.

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

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

The tool has zero parameters and the schema is empty, so there are no parameter semantics to document. The only contextual requirement, '当前组件', is implicit execution context rather than a parameter, so the baseline for zero-parameter tools applies.

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

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

The description states a specific verb '读取' (read/list), a clear target ('当前组件的全部 Transition'), and additional scope ('类型化关键帧'). The plural listing scope distinguishes it from the singular sibling fgui_get_transition, and it is clearly not a create/update/remove 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 phrase '当前组件' provides clear context: the operation applies to the active/current component. However, it does not explicitly contrast this with fgui_get_transition or other transition-related siblings, so when to choose this tool over alternatives is left to inference.

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

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

With no annotations provided, the description must disclose behavior, but it only states the action. It does not mention side effects like changing the active document, error handling when the document is not found, or whether the operation is safe or destructive.

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 filler. It conveys the essential purpose without unnecessary detail, making it highly concise.

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 requires project context, as seen from sibling tools like fgui_use_project, but the description does not mention prerequisites or whether the project must be active. It also does not explain possible error states, though an output schema exists. The minimal description is insufficient for a smooth agent interaction.

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 explicitly maps the parameters to 'package name' and 'resource name', providing semantic meaning beyond the bare property titles. However, it lacks details on formats, constraints, or relationships between the 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 function: opening a FairyGUI component document by package name and resource name. It uses a specific verb '打开' (open) and identifies the resource type, distinguishing it from sibling tools like save, publish, or insert 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 gives no guidance on when to use this tool versus alternatives such as fgui_get_active_document or fgui_get_tree. It only states the action without explaining prerequisites or situations where it is 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?

With no annotations, the description carries the full burden and only says the tool 'parses' XML, which implies read-only behavior but is never stated explicitly. It does not mention whether a document must be open, whether any state changes, or failure modes, so an agent cannot infer side-effect safety.

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 opens with a one-line purpose, then uses bullet points to list included content, followed by Args and Returns. It is well-organized and modest in length, though the Args/Returns blocks mostly restate schema 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 tool with no annotations and a 0%-described schema, the description omits usage context (prerequisites, when to prefer this over fgui_get_tree/search_component) and side-effect information. It gives the output categories but not enough for an agent to invoke it reliably in a workflow.

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 adds only 'package_name: package name' and 'component_name: component name', which are near-tautological translations of the parameter names. It does not define name formats, how to locate them, or any constraints, so it 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 states a specific action ('parse component and generate natural language description') and enumerates the output categories (base attributes, controllers, display list, Gear/Relation, transitions), making the tool's role clear. It does not explicitly contrast with siblings like fgui_get_tree or fgui_search_component, so it misses the top score for 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?

There is no explicit when-to-use/when-not-to-use or alternative routing. The intended use is only implied by the purpose statement and the included sections; no prerequisites or exclusions are given.

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

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

With no annotations, the description carries the full burden. It does disclose a meaningful side effect ('wakes up' the editor) and confirms it verifies protocol and capabilities, implying a non-mutating check. However, it omits details like failure modes, idempotency, or whether the editor must be running.

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 conveys purpose and behavioral nuance without redundancy. It is front-loaded and every word contributes meaning.

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 ping tool with no parameters and an output schema, the description sufficiently covers the operation and verification scope. It could mention that this is intended for initial connection checks, but that is implied by the name and content.

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 is complete. The description adds no parameter-specific detail, but none is required. A baseline of 4 is appropriate for a no-parameter 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 the tool wakes the FairyGUI Editor and verifies bridge protocol, version, and capabilities. It identifies a specific verb and resource, distinguishing it from general-purpose tools, though it could more explicitly contrast with the sibling 'fgui_status'.

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 fgui_status or fgui_get_project. It implies a startup/handshake role but lacks explicit prerequisites, exclusions, or recommended invocation context.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose a key trait: the preview will not be saved to FairyGUI assets, which signals non-destructive behavior. However, it does not mention other relevant behaviors such as whether the tool requires an active document, whether it changes the current selection, or what the 'status' operation returns. This leaves significant gaps for a tool with no annotation support.

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 well-structured sentence that front-loads the core functionality (play, pause, stop, seek, status) and then states the important caveat (preview not saved). Every word earns its place; there is no fluff or redundant detail. It is easy to parse and immediately actionable.

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 complexity (12 parameters, no schema descriptions, no annotations), the description is not complete enough. It does not explain how to specify which animation to preview, what the required 'kind' values mean, or what the 'status' operation returns. Even with an output schema, the agent lacks critical context about prerequisites and parameter relationships, making correct invocation difficult.

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

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

Schema description coverage is 0%, so the description must compensate for the 12 parameters. It only indirectly explains the 'operation' parameter by listing play/pause/stop/seek/status behaviors, but it fails to clarify parameters like kind, name, object_id, object_path, frame, delay, times, etc. Agents are left guessing how to target the correct animation or configure frame steps. This is insufficient for a tool with such a large parameter set.

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 function: play, pause, stop, seek, or query preview status for animations in the Editor. It uses specific verbs and identifies the resource (animation preview), and its purpose is distinct from any sibling tool (no other preview tool exists). The additional note that previews are not saved to FairyGUI assets further clarifies its non-persistent nature.

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 context: this tool is for interacting with animation previews in the Editor, which implies when to use it (e.g., when testing transitions or movieclips). It doesn't explicitly name alternatives or exclusions, but the 'in Editor' plus 'not saved' framing provides enough guidance to differentiate it from asset-editing tools. A small deduction because it doesn't state when not to use it (e.g., when persistent changes are desired).

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 it saves before publishing by default and allows selecting scope. However, it does not mention side effects, timeout implications, branch usage, or publish_desc_only behavior, which are relevant for a publish/export 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, well-structured sentence that front-loads the main purpose and covers key default behaviors and scope options. No unnecessary words or repetition.

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?

Despite having an output schema, the description is too brief for a tool with 6 parameters and no annotations. It omits semantics for several parameters (branch, timeout, publish_desc_only) and lacks details on side effects or error behavior, making it incomplete for an agent to use effectively.

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 has 0% description coverage for parameters. The description clarifies 'scope' and 'save_before_publish' implicitly, but leaves 'branch', 'timeout_seconds', and 'publish_desc_only' unexplained. With six parameters, the description only partially compensates for the missing 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?

Description clearly states the tool's function: '按工程发布设置导出 FairyGUI 包' (export FairyGUI packages according to project publish settings). It uses a specific verb (导出/export) and resource (FairyGUI包), and distinguishes it from sibling tools like fgui_get_publish_settings (read) and fgui_save_document (save).

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 provides context on default behavior (publishes current document's package and saves first) and scope options (specific package or all packages), but it does not explicitly compare with alternatives like fgui_save_document or fgui_list_packages. No when-not-to-use guidance is given.

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

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

With no annotations, the description carries the full burden. It discloses the key behavioral trait: prioritizing agent property transactions and falling back to native redo when the transaction stack is empty. This adds meaningful context beyond the name, though it does not cover side effects or return behavior, which is acceptable given the 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 a single, focused sentence that front-loads the key behavior. Every word earns its place, with no 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?

Given the tool has no parameters and an output schema, the description sufficiently explains the tool's operation and its unique fallback behavior. However, it assumes prior knowledge of 'Agent property transactions,' which could be clarified for 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 input schema has zero parameters, so schema coverage is 100%. The description does not need to explain parameters, and the baseline for 0 params is 4. It adds no param info, but none 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 clearly states the tool redoes actions, with a specific focus on agent property transactions and a fallback to native FairyGUI redo. This distinguishes it from sibling tools like fgui_undo and specifies the exact operation and behavior.

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 redo operations and explains the priority of agent property transactions, but it does not explicitly state when to use this tool versus alternatives or provide exclusions. The fallback behavior hints at when native redo is used, but explicit guidance 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?

With no annotations, the description carries full burden and discloses two critical behaviors: the operation is irreversible ('不可逆资源操作') and requires explicit force=True ('必须显式 force=True'). This is essential for safe invocation and goes beyond the schema, which only shows force defaulting to false without indicating it's mandatory for deletion. This is strong 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 sentence, front-loaded with the purpose and followed by the safety caveat. It is appropriately concise with no filler. However, the brevity comes at the cost of omitting parameter details, which is penalized under other dimensions.

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 optional parameters with zero schema descriptions and no annotations, the description is severely incomplete. It does not explain how to identify the target movieclip, the relationship between parameters, or the expected behavior with multiple identifiers. An agent cannot reliably construct a valid 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 coverage is 0% – no descriptions in the input schema. The description only mentions force, but fails to explain the identifiers: url, item_name, item_path, and package_name. Without this, an agent cannot determine how to specify the target movieclip. This is a critical 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 clearly states the verb and resource: '删除 MovieClip 包资源' (Delete MovieClip package resource). This is specific enough to distinguish from siblings like fgui_remove_transition and fgui_remove_object, which target different resource types. It could be more explicit about what 'package resource' encompasses, but the core purpose 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?

No guidance is provided on when to use this tool versus alternatives. The description does not mention exclusions, prerequisites, or context for invocation. The irreversibility warning is a behavioral note, not a usage guideline. An agent has no indication of when to choose this over fgui_remove_object or fgui_remove_transition.

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 reveals that the deletion is limited to non-root objects and does not persist, and it hints at rollback limitations by recommending fgui_discard_document. However, it omits other mutation-related traits like undo support, permissions, and impact on references.

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 efficiently conveys the action, scope, save behavior, and an alternative tool – no redundant 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?

The description lacks essential context: how to specify the object, what happens if no or multiple identifiers are provided, and behavior for root objects. Although an output schema exists, the operation's parameter semantics are entirely undisclosed, making the tool hard to use 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 description provides zero information about the three parameters (object_id, object_name, object_path). Since schema coverage is 0%, the description must compensate but fails to explain how to identify the target object, leaving agents without guidance.

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), the target scope (non-root objects), and the persistence behavior (does not save). This distinguishes it from sibling tools like fgui_discard_document, which is explicitly mentioned for rollback scenarios.

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

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

The description explicitly advises using fgui_discard_document when reliable rollback is needed, providing a clear alternative and context for when this tool is not the right choice.

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

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

With no annotations, the description carries the behavioral burden. It clearly indicates a destructive mutation (delete) and adds the valuable recovery behavior that fgui_undo can restore it. However, it does not cover failure modes or prerequisites beyond 'current component'.

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

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

One short sentence with no filler; the core action and the undo-recovery note are both front-loaded and useful.

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 single-parameter deletion tool with an output schema, it covers the essential action and undoability. It is still slightly incomplete about required context (e.g., must have an active component) and error behavior, but those are not severe gaps.

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

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

Schema coverage is 0% and the description does not explain the name parameter except by implication. An agent must infer that 'name' is the name of the transition to delete; there is no mention of how to obtain valid names or any format/validation details.

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 (删除/delete) and resource (a Transition in the current component), and it is clearly distinct from the sibling fgui_remove_transition_item because it targets the whole Transition, not an item. The undo mention does not obscure the 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 about when to choose this over alternatives such as fgui_get_transition, fgui_upsert_transition, or fgui_remove_transition_item. There is also no mention of prerequisites like having a document/component open; only the phrase 'current component' implies context.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It does disclose that the operation deletes an item and that fgui_undo can restore it, which is useful for a destructive action. However, it omits preconditions, invalid-index behavior, and whether changes require saving.

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 filler. The core action is front-loaded, and the undo note adds useful information without bloating the text.

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

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

For a simple two-parameter tool with an output schema, the description covers the action and reversibility. However, it leaves the name parameter ambiguous and omits prerequisites such as an open document or existing transition. An agent could likely infer the intent, but the description alone is not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that item_index refers to the index of the keyframe item, but it never explains what name refers to, presumably the transition name. This is only partial compensation for the undocumented 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 the specific verb '删除' (remove) and identifies the resource as a keyframe item at a specified index within a Transition. It is clear enough to distinguish from removing an entire transition, though it does not explicitly name sibling tools.

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

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

There is no guidance on when to use this tool versus fgui_remove_transition, fgui_update_transition_item, or fgui_add_transition_item. The mention of fgui_undo is recovery information, not selection guidance, so usage must be inferred entirely from the operation name.

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 discloses that after saving, a disk-XML comparison is performed by default, and that Button states are unsupported. However, it does not mention reversibility, permissions, failure behavior, or side effects on the document, leaving significant 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 only two sentences, front-loading the primary action and adding a limitation in the second sentence. It is free of fluff, but given the tool's complexity (8 params), it is perhaps overly terse, so I don't give a perfect score.

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 an 8-parameter mutation tool with no annotations and zero schema coverage, the description leaves out essential context: what each parameter does, how object selection works, what the verification does, and when to pass save=true. The presence of an output schema mitigates return-value concerns but not the parameter and usage gaps.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It does not mention resource_url, object_id, object_name, object_path, save, state, verify, or expected_type. The only faint clue is the reference to Image/Loader and Button states, which does not clarify any parameter's semantics.

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

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

The description states a specific action ('替换 Image/Loader 图片引用') and identifies the resource type (Image/Loader), distinguishing it from general tools like set_property and import_image. It also adds a constraint (Button states not supported) that further delimits 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 explicit guidance on when to use this tool versus siblings like set_property or import_image. The only exclusion is Button states, but no alternative tools are named or conditions given. The reader must infer usage from the purpose, which is not enough.

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

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

No annotations are provided, so the description carries the full burden. It discloses an important side effect: '清空 Agent 属性事务栈' (clears the Agent property transaction stack), which is valuable behavioral info. However, it does not explain the implications of clearing the stack (e.g., loss of undo history) or any prerequisites/errors.

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

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

One compact sentence with clear front-loading: action verb + target resource + side effect. 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?

With 0 parameters, an output schema present, and clear scope, the description is largely complete. The only minor gap is lack of detail about what happens after saving (e.g., return value or failure conditions), but the output schema presumably covers 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 0 parameters, so baseline is 4. The description correctly omits parameter details, and no additional semantics are 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 '保存' (save) with an explicit resource scope: '所有 FairyGUI 文档、已打开包和工程' (all documents, open packages, and project). This clearly differentiates it from sibling tool fgui_save_document, which saves a single document.

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

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

The word '显式' (explicitly) and '所有' (all) indicate when this tool is appropriate: when a complete save of all open FairyGUI state is needed. It does not name alternatives explicitly, but the scope is unambiguous enough for an agent to distinguish from single-document save 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 full responsibility for behavioral disclosure. It explicitly states that the operation clears the Agent property transaction stack, a key side effect beyond the save itself, which is valuable for the agent's state awareness.

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 includes the most important side effect. 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?

Given there are no parameters, the description covers the core action and a critical behavioral side effect. An output schema exists for return values, so the description does not need to detail them. This is fully adequate for a simple save 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 tool has zero parameters, so there is no parameter semantics to clarify. Baseline for 0 parameters is 4, and the description adds no unnecessary param information.

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 precisely states the action 'save' and the target 'current FairyGUI document', and adds a specific side effect (clearing the agent property transaction stack). This clearly differentiates it from siblings like fgui_save_all and fgui_discard_document.

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 indicates it applies to the 'current' document, giving clear context for when to use it. However, it does not explicitly mention alternatives or state when not to use it, so it lacks explicit exclusionary 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?

Annotations are absent, so the description carries the full burden. It only states what it does (search) and the return (list of matches), but does not explicitly say it is read-only, whether it requires an open document, or if there are any side effects or performance implications. For a search operation, more behavioral context would be expected.

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

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

The description is compact and well-structured with Args and Returns sections. It contains no fluff and is easy to scan. It could be slightly more informative but remains 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 tool with one parameter, an output schema, and a simple search operation, the description covers the basic meaning of the parameter and the return value. However, it lacks usage context (when to prefer this over list tools) and behavioral transparency (read-only, prerequisites). Given the simplicity, a score of 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 schema provides only the parameter name and type with 0% description coverage. The description adds meaning by stating that name_pattern is a 'component name pattern' and notably 'supports partial matching', which is valuable and not present in the schema. This compensates well for the missing schema 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 clearly states the action ('search components') and scope ('in all packages'), with a specific resource. It implies a distinguishing behavior from list-type siblings (search with pattern vs. list), but does not explicitly contrast itself with fgui_list_items or fgui_list_packages. Still, the operation 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?

There is no guidance on when to use this tool over alternatives like fgui_list_items or fgui_get_package_info. No context about prerequisites (e.g., needing an active document or project) or conditions that favor search over listing.

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 does not state whether this operation is non-destructive, how it affects prior selections, what happens if multiple objects match, or error behavior when no object is found. The minimal wording leaves these aspects opaque.

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 action and lists the three selection methods. Every word earns its place; there is no redundancy or filler.

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

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

Despite having an output schema, the tool has 3 optional parameters with zero schema descriptions and no annotations. A single sentence is insufficient to cover selection semantics (e.g., disambiguation, return behavior, or side effects). The tool is under-specified for reliable autonomous 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 description partially compensates for the 0% schema coverage by clarifying that object_id, object_name, and object_path are alternative means of selection ('or'). However, it does not specify whether they are mutually exclusive, their precedence, or expected format (e.g., full path vs. relative path). This adds some semantic value but leaves key details ambiguous.

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 ('select an object') and the resource (object), with three specific locator methods: ID, path, or unique name. This verb+resource pair is distinct from siblings like fgui_insert_object or fgui_remove_object, making 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?

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites (e.g., an open document), selection context, or why one locator method might be preferred over another. The description is purely functional with no usage context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses two key behaviors: the modification is not saved and the action is tracked in the undo/redo transaction stack, which addresses reversibility and persistence. Missing details include side effects, return values, and error conditions, but the core behavioral traits are covered.

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, consisting of two short sentences with no filler. It front-loads the action and the key constraint, and every word contributes meaning.

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?

Despite the tool having 5 parameters, 2 required, and 0% schema description coverage, the description provides only minimal guidance. It omits any explanation of the whitelist concept, how to specify the target object among three options, or what values are acceptable. The existence of an output schema does not compensate for these gaps, making the description incomplete for reliable use.

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 compensate. It only implies the existence of property_name and value but provides no explanation of valid property names, value types, or the three object identification parameters (object_id, object_name, object_path). This is a significant gap for correct invocation.

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 (modify whitelisted properties) and a key constraint (does not save), which distinguishes it from sibling tools like fgui_save_document. The mention of undo/redo transaction stack further separates it from save and redo operations. However, the term 'whitelist' is ambiguous and not explained, leaving some purpose clarity gaps.

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

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

The description explicitly indicates this is a non-persistent operation that enters the undo/redo stack, implying when to use it: for reversible, in-memory property changes. It also implicitly warns against using it when persistence is required, though it does not name specific alternative tools. The usage context is reasonably 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that a text style is set; it does not reveal side effects, whether it mutates persistent state, what verification or saving does (despite the verify/save parameters suggesting these behaviors), or how it interacts with selection. No contradiction with annotations exists because none are present.

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, and the core action is front-loaded. However, it is under-specified rather than optimally concise—for a tool with 6 parameters and no annotations, this brevity sacrifices needed 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 6-parameter tool with nested objects, an output schema, and zero annotation coverage, a one-line description is inadequate. It does not explain return values, selection semantics, save/verify behavior, or the 'unified' scope, so an agent lacks essential context to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It adds some meaning by mapping 'style' to a text style and indicating the target objects are TextField/RichText, but it does not clarify the three object-reference parameters (object_id/object_name/object_path) or the save/verify booleans, leaving most parameters semantically opaque.

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), a resource (TextField/RichText), and the scope (统一文本样式/unified text style), which is enough to identify the tool's basic operation. It can be distinguished from the sibling fgui_get_text_style (get vs set), though the meaning of 'unified' is somewhat vague and the distinction from fgui_set_property is not addressed.

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 about when to use this tool versus alternatives. It does not mention fgui_get_text_style, fgui_set_property, or any conditions, prerequisites (e.g., an open document), or exclusions. The one-line description leaves all usage decisions to the agent.

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

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

No annotations are provided, so the description bears the full responsibility. It does disclose a read-only operation ('读取') and the key non-waking behavior ('不主动唤醒编辑器'), which is useful. However, it does not explain what 'bridge heartbeat' entails, how it behaves when the editor is not running, or any other edge cases, leaving gaps in 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 a single sentence that efficiently conveys the core purpose and key behavioral caveat. There is no fluff, and it is appropriately sized for a simple no-parameter status 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?

Given the tool's simplicity, the presence of an output schema, and the description covering purpose and the critical 'does not wake' behavior, it is fairly complete. However, it could provide a bit more context about what 'bridge heartbeat' represents or how this tool relates to other status checks, preventing a perfect score.

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 description coverage is trivially 100%. The description adds no parameter-specific semantics, but with no parameters to explain, the baseline of 4 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 reads ('读取') local FairyGUI project selection and bridge heartbeat, which is a specific verb+resource combination. It also distinguishes itself from siblings by noting it does not actively wake the editor, which sets it apart from tools like fgui_ping or fgui_get_project.

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 guidance is provided about when to use this tool versus alternatives. The statement '不主动唤醒编辑器' implies it is a safe non-intrusive status check, but there is no mention of alternatives, exclusions, or specific scenarios. This is insufficient for helping an agent decide between fgui_status and related 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. It discloses the priority/fallback behavior, adding value. However, it leaves ambiguous details such as whether undo is single-step, what happens when there is nothing to undo, and the exact definition of 'transaction stack'.

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

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

One concise front-loaded sentence with no wasted words, effectively communicating the essential behavior.

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 description covers the core undo behavior and fallback, it does not explain the concepts of 'Agent attribute transactions' or the transaction stack, which could be ambiguous to an AI agent. With an output schema present, return values are covered elsewhere, but the behavioral edge cases are not specified.

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 there is nothing to describe. The description does not need to explain parameter semantics.

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

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

The description clearly states the tool performs undo operations, prioritizing agent property transactions and falling back to native FairyGUI undo. This distinguishes it from sibling tools like fgui_redo (opposite action) and fgui_get_history (viewing history).

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 defines when to use this tool (to undo) and explains the decision logic: it tries agent transactions first, then native undo. However, it does not explicitly mention alternatives or exclusions, though the redo tool is an obvious opposite.

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, but it only states that frames are replaced when frame_paths is provided. It does not disclose whether this is destructive to existing frames in other cases, whether it requires an active document, how undo/saving is affected, or what side effects updating other properties might have.

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 filler, and the most functional detail about frame_paths is included. It is concise and readable, though the brevity comes at the cost of missing important operational context.

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 12-parameter mutation tool with no annotations and no parameter descriptions, this description is far too sparse. An agent cannot determine how to identify the target MovieClip, what the optional parameters do, whether frame_delays must align with frame_paths, or what happens when frame_paths is omitted.

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% across 12 parameters, and the description only adds meaning for frame_paths by calling it an ordered image sequence that replaces animation frames. The other 11 parameters such as fps, speed, swing, frame_delays, item_path, and package_name receive no semantic explanation.

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

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

The description names the operation ('更新已有 MovieClip') with a specific resource and rescope, and the '已有' wording distinguishes it from create/remove/get movieclip tools. The additional frame_paths condition describes a concrete behavior, though '更新' remains somewhat generic about what else can be updated.

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 about when to use this tool versus alternatives like fgui_create_movieclip, fgui_set_property, or fgui_replace_object_resource. The only implied usage is 'existing MovieClip', but there is no explicit when-to-use or when-not-to-use instruction.

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?

There are no annotations, so the description carries the full disclosure burden. It discloses that the operation replaces/overwrites an existing item and explicitly notes it can be undone with fgui_undo/redo. It does not explain behavior on invalid index, validation rules, or whether a save step is required afterward.

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 front-loads the action and target, then adds a helpful undo note. It is concise and free of filler, though its brevity leaves important parameter context unaddressed.

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 all 3 parameters required, one deeply nested item object, and no annotations, the description is too sparse to fully guide an agent. The output schema exists so return values need not be explained, but the meaning of 'name' and the structure of the replacement item are essential and missing.

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

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

Schema description coverage is 0%, so the description must compensate. It only maps '指定索引' to item_index and '关键帧项' to item, but does not explain the required 'name' parameter or how to construct the complex TransitionItem value. Most parameter semantics remain unspecified.

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: '替换' (replace) the keyframe item at a specified index of a Transition. This distinguishes it from add/remove/upsert transitions, though it does not name a sibling explicitly.

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 wording implies use when modifying an existing keyframe item at a known index, and the undo mention adds practical guidance. However, there is no explicit comparison to fgui_add_transition_item or fgui_remove_transition_item, and no prerequisites such as needing an open document or existing transition.

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 is atomic and undoable, and that it does a complete replacement. However, it omits many behavioral details such as prerequisites (open document), what happens to existing transitions, and side effects on related items. It adds some context but not enough for a mutation tool without annotation support.

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 conveys the core operation and atomicity. It is appropriately short and front-loaded, though it lacks any structural breakdown or additional context that might be warranted for such a complex 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 tool with a very large schema (many nested types) and no annotations, the description is far too minimal. It does not explain the transition definition structure, required fields, usage context (e.g., which document it applies to), or any return/error behavior. The output schema exists but does not substitute for the missing operational context.

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

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

Schema description coverage is 0% and the description does not explain the single 'transition' parameter or its structure. While the parameter is a self-contained object definition, the description adds no meaning beyond the schema, and with zero coverage it fails to compensate. The agent must infer semantics from the schema 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 verb 'create or completely replace' and the resource 'Transition', which distinguishes it from sibling tools that add/update individual items. However, it does not explicitly name alternatives, so it gets a 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 phrase 'declaratively create or completely replace' implies a whole-object operation, and the atomic undo/redo note hints at safe usage. But there is no explicit 'when to use vs. not use' or reference to alternatives like fgui_add_transition_item or fgui_update_transition_item, so guidance is only implicit.

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 available, the description carries the full burden of behavioral disclosure. It mentions selecting for the session but does not explain side effects (e.g., overriding previous selection), validation behavior, or error handling. This is a state-changing operation, yet the description remains surface-level.

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 action and resource. Every word is informative, with no filler or 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 simple one-parameter setter tool, the description is minimal but acceptable. It covers the core purpose and parameter semantics, but lacks usage context (when to call) and behavioral details. The presence of an output schema reduces the need to describe return values, but the lack of guidelines makes it 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?

The schema has one parameter (project_path) with no description (0% coverage). The tool description compensates by explaining the accepted path types (.fairy file, project directory, or repository directory), adding meaning beyond the raw schema. However, it does not specify path format (relative vs. absolute) or other 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 the tool's function: selecting a .fairy file, FairyGUI project directory, or repository directory for the current MCP session. It uses a specific verb ('select') and distinguishes from siblings like fgui_get_project, which likely retrieves the current selection rather than setting it.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, ordering (e.g., use before other operations), or exclusions. The context implies it is a setup step, but the description never says that explicitly.

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 of behavioral disclosure. It communicates that this is an inspection-style operation ('checks') and lists the specific validation categories, plus a return value. However, it does not explicitly state that the operation is read-only, how failures are reported, or whether it returns a pass/fail status versus a list of issues.

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

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

The description is compact and well-organized: a clear summary, a scannable bullet list of validation criteria, and an Args/Returns section. There is slight redundancy between the title line and the opening sentence, but overall every section 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 simple two-parameter validation tool, the description is nearly sufficient: it states what is checked and that a result is returned, and an output schema exists to cover return details. However, it omits any usage context relative to fgui_verify_document and gives no indication of what the caller should do with the result, leaving moderate ambiguity.

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 merely restates the parameter names as 'package name' and 'component name' in Chinese. It adds no format guidance, constraints, examples, or details about how the names must be expressed, providing no value beyond the schema property titles.

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

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

The description clearly identifies the action ('validate/check component') and resource ('component'), and enumerates four concrete validation dimensions: XML correctness, required attributes, naming conventions, and resource references. It does not explicitly distinguish itself from the sibling fgui_verify_document, 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 implies the tool is used to validate a component, but it gives no guidance on when to run it, what conditions make it appropriate, or how it relates to alternatives like fgui_verify_document. No exclusions or context 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?

With no annotations, the description does the heavy lifting and clearly discloses the key behavioral traits: read-only, no save, no reload, disk-XML default, and snapshot-only behavior when expected is absent. It doesn't cover errors or selection nuances, but for a non-mutating verifier this is strong 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?

A single compact sentence packs purpose, side effects, default behavior, and an edge-case fallback with no filler. Every clause carries meaningful 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?

The description provides a solid behavioral overview, but with six undocumented parameters and no target-selection explanation, an agent cannot reliably construct the right invocation. The presence of an output schema helps with return expectations, but the parameter semantics gap remains a significant completeness problem.

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 prose only references 'expected' without explaining its shape or how the target is identified. The remaining parameters (object_id, object_name, object_path, read_xml, max_depth) are left undocumented in both schema and description, so the description barely compensates for the parameter 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 clearly states the action (read-only verify), the resource (disk XML), and the side-effect boundary ('不保存、不重载'). It is unambiguous about the tool's core purpose, though it doesn't explicitly name or compare sibling tools, and 'target' is left slightly vague.

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 alternatives or when-to-use versus sibling tools are given. However, the '只读' and '不保存、不重载' phrasing implies this is for non-mutating verification against disk XML, so the agent can infer the appropriate general context without strong exclusion guidance.

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