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

With no annotations, the description carries the full behavioral burden. It does disclose meaningful verification behavior (save=True compares the disk XML item count; external_reload requires save=True and performs a close/reopen comparison; response strength is reload/disk/none). However it says nothing about mutation side effects, permissions, or reversibility for a write 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?

Two tight sentences, front-loaded with the action, with the save/external_reload mechanics following. No filler, though the response-strength detail is somewhat compressed.

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 values need not be documented, and the description usefully covers the verification workflow. But for a mutation tool with no annotations and 0% parameter coverage, key gaps remain around the item structure, verify, and mutation semantics.

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 5 parameters, so the description must compensate, but it only touches save and external_reload (including the save=True dependency). The required params name and item, plus the verify flag, are left entirely unexplained by both schema and description.

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

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

The description states a specific verb and resource: adding a typed keyframe track item ('类型化关键帧轨道项') to a Transition. This clearly distinguishes it from the remove/update siblings by the 'add' action. It stops short of naming the specific alternatives (fgui_upsert_transition, fgui_update_transition_item) it must not be confused with.

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 explains the effect of save and external_reload, but gives no guidance on when to use this tool versus fgui_upsert_transition or fgui_update_transition_item. There are no prerequisites or exclusions stated; the reader must infer that 'add' means creating a new item.

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 disclosure burden. It adds real behavioral detail (save=True persists package+project and compares package.xml entries; component-class resources don't support external_reload; strength capped at disk), but leaves the mutation surface, permissions, and overwrite/rename behavior undefined.

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

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

Two compact paragraphs, front-loaded with the core action, which is good. But the second paragraph is cryptic jargon (external_reload, strength 上限) that spends words without clarifying how to call the 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 an 18-parameter creation tool with no annotations and no parameter descriptions, the definition is far too thin; the output schema excuses return-value documentation, but the invocation surface (mode selection, image input, naming, folder placement) is essentially undocumented.

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 18 parameters, so the description must compensate and does not. It only touches save and the state-image ordering, leaving mode (enum), image_urls, auto_rename, create_icon, create_text, folder_path, as_list_item, extension_id, and the layout flags entirely unexplained.

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 concrete verb and resource: '创建标准 FairyGUI Button 组件' (create a standard FairyGUI Button component), which clearly separates it from fgui_create_component and fgui_create_movieclip siblings. However it never explicitly contrasts itself with fgui_create_component, so the distinction is left to inference.

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

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

The description gives no when-to-use guidance, no prerequisites (e.g. an active project/package via fgui_use_project), and no routing to alternatives such as fgui_create_component. It documents side effects of save=True but not when a caller should choose them.

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 at all, the description carries the full burden and does disclose meaningful behavior: default open-but-don't-save, default rejection on name conflict, that save=True triggers package/project save plus a package.xml comparison, and that component resources have no reliable asset reload with strength capped at disk. These are non-obvious operational facts. It stops short of explaining remaining behaviors (verify, exported, create_folders effects), so not a 5.

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

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

Two tight sentences, front-loaded with the core action and defaults, then the save=True nuance. Slightly dense jargon (external_reload, strength 上限为 disk) but no wasted 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?

An output schema exists, so return values need not be described, and the safety/default behavior is reasonably covered. But for a 12-parameter mutation tool with zero annotations and zero schema descriptions, leaving most parameter effects unexplained makes the definition only minimally complete.

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

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

Schema coverage is 0% across 12 parameters, and the description only explains save (its save-time behavior) and implicitly the duplicate-name handling tied to auto_rename. Width, height, verify, exported, folder_path, extension_id, create_folders and open_after_create are left entirely undocumented in both schema and description, so it does not compensate for the coverage gap.

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

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

The description gives a specific verb+resource — creating a component document in a named package — which is clear and actionable. However, it does not differentiate itself from the many similar create tools in the sibling list (fgui_create_button, fgui_create_movieclip), so it does not reach 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?

It conveys default behaviors (opens but does not save, rejects on duplicate names) which implies intended usage, but there is no explicit when-to-use guidance and no comparison against the sibling create tools. The agent must infer 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. It does disclose non-obvious behavior: the frame sequence is delegated to FairyGUI native animation resources, save writes package.xml plus resource files and then verifies them, and external_reload unloads/reloads the asset with a response strength of reload/disk/none. It still omits that 'replace' destroys an existing MovieClip, permission requirements, and the effect of the timeout.

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 purpose is front-loaded in the first clause and the whole thing is two sentences with no filler. The second sentence is dense but every clause carries information, so it is appropriately sized for a 15-parameter 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 15-parameter mutation tool with zero annotation coverage, the description is thin. An output schema exists (so return shape is partly covered, and the description does explain the strength field), but the majority of input parameters and the destructive replace path are undocumented, leaving the agent under-informed.

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?

15 parameters with 0% schema description coverage, and the description explains only save, external_reload, and implicitly frame_paths. fps, swing, repeat_delay, frame_delays, conflict_policy, create_folders, exported, folder_path, verify, and timeout_seconds get no semantic help, so 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?

States a specific verb pair (create or replace) and resource (MovieClip) with the input format ('ordered absolute image paths'), which cleanly separates it from fgui_update_movieclip and fgui_get_movieclip. It does not explicitly name the sibling alternatives, so it lands just 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?

Provides conditional guidance for two flags (save=True triggers verification; external_reload=True requires save=True), which implies when those modes apply. However, it never states when to use this tool versus fgui_update_movieclip or how conflict_policy should drive the choice, so usage is only partially implied.

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

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

No annotations are provided, so the description carries the 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?

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 and does well: it declares this is a disk write, enumerates the conflict-resolution behaviors (reject/auto-rename/replace), and explains the save/external_reload interaction including the returned strength values. It omits permissions and reversibility, but adds substantive context beyond the 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?

Two compact paragraphs, front-loaded with the purpose and mutation warning before the save/reload mechanics. Dense but every clause carries information; no filler.

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

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

An output schema exists, so return values need not be spelled out, and the description usefully mentions the strength field. However, for an 11-parameter mutation tool with 0% schema coverage, several parameters remain opaque, leaving the definition only partially complete.

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

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

Schema coverage is 0% across 11 parameters, so the description must compensate. It explains save, external_reload, conflict_policy and implies source_path's absolute-path requirement, but leaves verify, exported, folder_path, create_folders, resource_name and timeout_seconds undocumented, so the coverage gap is only partly filled.

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

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

States a specific verb and resource ('从绝对本地路径导入字体' – import font from an absolute local path) plus the mutation nature. This clearly distinguishes it from siblings like fgui_import_image and fgui_import_sound without needing to open the schema.

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

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

The description implies usage (importing a font asset, with conflict handling) but never states when to choose this over alternatives or what prerequisites apply. The sibling set makes the resource distinction obvious, so the omission is not misleading, just 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 and does well: it discloses this is a disk write, that conflicts resolve via reject/auto-rename/replace, that save=True triggers verification against package.xml entries, and that external_reload requires save=True and yields a response strength of reload/disk/none. Missing only auth/permission or timeout characteristics.

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

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

Two dense but front-loaded sentences: the write nature and conflict behavior come first, then the save/external_reload semantics. No filler, though the second sentence packs several conditions into one run-on clause.

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 values needn't be fully explained, and the description covers the conflict and save behavior well for a mutation tool. But with 11 parameters at 0% schema coverage, roughly half the inputs (folders, resource naming, timeout) are undocumented anywhere, leaving material 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% across 11 parameters, so the description must compensate and it partially does: it explains save, external_reload (and its dependency on save), the conflict_policy enum values (拒绝/自动改名/替换 = error/auto_rename/replace), and the verify comparison behavior. However, exported, folder_path, resource_name, create_folders, and timeout_seconds remain completely 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?

States a specific verb+resource combination (从绝对本地路径导入图片 = import image from absolute local path) and clarifies it is a disk-write operation. It is distinguishable from fgui_import_font/fgui_import_sound by the 'image' resource, though it never names those siblings 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?

It explains what save/external_reload do internally but never states when to choose this tool over alternatives like fgui_replace_object_resource or the other import tools. No prerequisites, no when-not-to-use guidance.

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

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

With no annotations, the description carries the full behavioral burden and delivers well: it discloses that this is a disk write, that same-named sounds can be replaced, that save persists the package and project, that external_reload requires save=True and unloads/reloads the asset, and what response strength values mean. It omits permission/error and failure-mode context, but the mutation profile is solid.

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

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

Two front-loaded sentences: purpose and write-nature first, then the save/external_reload behavior. Efficient, though the nested parenthetical clause about external_reload is slightly dense.

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 values needn't be explained, and the key behavioral model is present. However, for an 11-parameter mutation tool with no annotations and 0% schema coverage, leaving most parameters unexplained is a meaningful gap for correct invocation.

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

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

Schema coverage is 0% across 11 parameters, so the description must compensate, yet it only explains save and external_reload (and hints at replacement, i.e. conflict_policy=replace). Params like verify, exported, folder_path, create_folders, resource_name, and timeout_seconds remain undocumented in both schema and 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?

States a specific verb and resource ('从绝对本地路径导入声音资源') plus the write nature ('属于磁盘写入') and the replace behavior. This clearly distinguishes it from sibling import tools like fgui_import_image and fgui_import_font without the agent having to open any 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?

Describes what save=True and external_reload=True do, which implies when those modes are relevant, but never names an alternative tool or states when-not to use this one. Usage is inferable rather than explicit.

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

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

With no annotations, the description carries the full behavioral burden and delivers the crucial disclosure that structural operations cannot be undone by the Agent property transaction stack, plus the save/verify/external_reload interplay and the response 'strength' field. It stops short of permission/document-state requirements.

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 core action is front-loaded in the first clause, followed by only the behavioral facts that matter. Every sentence earns its place with no filler.

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

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

Output schema exists, and the description usefully explains the 'strength' return field, so return values are largely covered. However, for an 8-param mutation tool with no annotations, it omits prerequisites such as required active document/selection state and insertion target 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 coverage is 0%, so the description must compensate for 8 params. It explains the non-obvious booleans well (save, external_reload, and implicitly verify via disk comparison), but x, y, name, url, and insert_index get no added meaning beyond their self-descriptive 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?

States a specific verb and resource: '插入已有 ui:// 资源' (insert an existing ui:// resource). This distinguishes it conceptually from the create_* siblings that build new objects, though it never names an alternative. The action 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 explicit when-to-use or when-not-to-use guidance, and no comparison against sibling insertion/creation tools. The notes about save/verify behavior are parameter mechanics rather than selection guidance, so an agent gets no help deciding when this tool is 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 full behavioral burden. It discloses two useful facts — scope is limited to the root component (not descendants) and the FGUI 0.8.8+ version requirement — but says nothing about read-only nature, what happens when no document is open, or error behavior.

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

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

One short sentence, front-loaded with the verb and resource, with the scope qualifier and version constraint appended compactly. No filler.

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

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

For a zero-parameter read-only listing tool with an output schema covering return values, the description is nearly complete: scope and version are stated and results need not be described. Only failure/precondition behavior (e.g., requires an active document) is missing.

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

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

The tool takes zero parameters, so the schema has nothing to document and the baseline for zero-param tools applies. Nothing in the description is needed to clarify inputs.

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

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

States a specific verb (列出/list), resource (Controller), and scope (当前文档根组件 — the root component of the current document), which cleanly separates it from siblings like fgui_list_transitions and fgui_list_items. It does not explicitly name an alternative, but the resource is unambiguous enough that an agent can select it without opening the schema.

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

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

There is no explicit when-to-use or when-not-to-use guidance. Only weak implied usage (enumerate controllers for inspection) can be inferred, and no sibling tool is named as an alternative or complement (e.g., fgui_set_controller).

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 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. 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 the load well: it declares the operation irreversible, states the force=True requirement, describes save=True verification against package.xml, and notes no reload primitive exists (strength capped at disk). That is meaningful behavioral context beyond the bare 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?

One front-loaded paragraph that leads with purpose and irreversibility, with no wasted sentences. Some dense jargon ('诚实的重载基元', 'strength 上限为 disk') is terse but not bloated.

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 values need no explanation, and the mutation's risk profile is disclosed. However, for a 7-param no-annotation tool it leaves the target-identification parameters ambiguous, which is a real gap for correct invocation.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate, but it only touches force, save, and verify. It never explains how the target is identified (url vs item_name/item_path/package_name), leaving the most important selection parameters 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?

States a specific verb and resource: '删除 MovieClip 包资源' (delete MovieClip package resource). This distinguishes it from fgui_remove_object/fgui_remove_transition by resource type, though it doesn't explicitly name those siblings.

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

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

Provides a prerequisite ('必须显式 force=True') but no when-to-use conditions or exclusions relative to sibling removal/update tools. Guidance is implied rather than stated.

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

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

With no annotations, the description carries the full burden and does substantial work: it explains that removal is treated as absence verification, that save=True persists then confirms the node is gone from disk XML, that external_reload=True reopens and requires save=True, and that the response strength field reports reload/disk/none. It does not mention undoability (fgui_undo is a sibling) or permission requirements, leaving a gap for a destructive mutation.

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?

Purpose and the routing rule to discard_document are front-loaded, followed by the verification semantics. Dense but each sentence carries information; the two paragraphs are slightly redundant in re-stating save=True across both sentences.

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 values need not be explained, yet the description still adds value by decoding the strength field. For a destructive tool with no annotations the coverage is good, though selector-parameter semantics and undo behavior remain unaddressed.

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

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

Schema coverage is 0% for six parameters, so the description must compensate. It clarifies the semantics of save, external_reload, and verify's verification flow, but the three alternative selector parameters (object_id, object_name, object_path) are never explained — an agent cannot tell whether they are mutually exclusive or which to prefer.

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

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

States a specific verb and resource ('删除非根对象' / delete non-root object) and immediately scopes it against a sibling, fgui_discard_document. An agent can distinguish this from discard_document without opening either 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?

Explicitly names the alternative tool and the condition that selects it: '需要可靠回退时使用 fgui_discard_document' (use discard_document when you need reliable rollback). This is a concrete when-not rule plus a named alternative, not implied usage.

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

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

With no annotations provided, the description carries the full burden and it does add real behavioral context: the removal is recoverable via fgui_undo, save=True persists to disk, and external_reload requires save=True. It stops short of disclosing failure behavior for a non-existent name or any permission prerequisites.

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

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

Front-loaded with the core action and recoverability, then a second short paragraph on save/verify semantics. Dense but each sentence adds operational information; no filler.

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

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

For a destructive tool with no annotations, it covers recoverability, persistence, and verification strength (reload/disk/none). An output schema exists so return shape need not be explained, though missing error/prerequisite cases keep it from being fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains save and external_reload (including the save=True dependency) and implies verify via '默认确认', but does not clarify what verify=False does or what 'name' refers to (transition name vs. component). Roughly half the parameters are meaningfully covered.

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

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

States a specific verb (删除/remove) and resource (Transition) with an explicit scope ('当前组件中的一个'). It is clearly distinguishable from siblings like fgui_remove_transition_item, fgui_upsert_transition, and fgui_get_transition.

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

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

Usage is implied by the verb and the description names fgui_undo as the recovery path, which is a useful routing hint. However, it never states when to choose this tool over fgui_remove_transition_item or fgui_upsert_transition, nor any preconditions such as an active/selected component.

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 does well: it discloses reversibility via fgui_undo, the save/disk-comparison behavior, that external_reload requires save=True, and the possible response strength values (reload/disk/none). It does not cover permissions or side effects on other transition entries, so not a 5.

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

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

Two compact paragraphs with the core mutation action front-loaded, followed by the save/verification semantics. Every sentence carries information; no filler 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?

For a destructive mutation with no annotations and a 0%-covered schema, the description supplies the essential behavioral context (undo recovery, save/verify flow, external_reload dependency) and an output schema exists to cover return values. Minor gaps remain around the unexplained required parameters.

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 5 parameters, and the description explains only some of them: save, the implicit verify comparison behavior, and external_reload (including its dependency on save). The required name and item_index parameters receive no explanation, leaving a meaningful gap the schema does not fill.

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 precise verb+resource+scope: removing the keyframe item at a specified index of a Transition ("删除 Transition 指定索引的关键帧项"). The resource name (transition item) inherently distinguishes it from fgui_remove_transition and fgui_add_transition_item, but it never explicitly names those siblings, so it stops short of a 5.

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

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

It notes that the operation is reversible via fgui_undo, which hints at usage context, but gives no explicit when-to-use/when-not guidance or direct comparison to fgui_remove_transition or fgui_update_transition_item. Usage is implied rather than stated.

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

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

With no annotations, the description carries the full burden and does so well: it discloses the default post-save verification against disk XML, the side effect of closing and reopening the document under external_reload, the save=True dependency, and the meaning of the response strength field (reload/disk/none). It omits auth/permission needs and what happens to the prior reference, so not quite a 5.

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 core action is front-loaded in the first clause, and the two-sentence structure is dense but largely waste-free. The semicolon-heavy construction is a little compressed but every statement conveys operational 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?

An output schema exists so return values needn't be explained, and the description covers verification behavior thoroughly. However, for a mutation tool with no annotations and 0% parameter documentation, the seven undocumented parameters leave the definition incomplete for correct invocation.

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

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

Schema description coverage is 0% across 9 parameters, so the description must compensate. It explains save and external_reload behavior, but leaves resource_url, object_id, object_name, object_path, state, verify, and expected_type entirely undocumented, which is a substantial gap for a 9-param 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 states a specific verb+resource: replacing Image/Loader image references via the Editor API, and adds a scope limitation (Button states not supported). An agent can tell what the tool does. It does not, however, explicitly differentiate itself from siblings like fgui_set_property or fgui_import_image.

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

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

It provides a clear exclusion ('Button states not supported') and a conditional requirement (external_reload needs save=True), which edges toward when-to-use guidance. However, it never names alternatives or states the general situation in which this tool should be chosen over related tools, so usage is only implied.

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

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

No annotations are provided, so the description carries the 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?

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, the description carries the full burden and does disclose significant side effects: pages replaces the whole page set and reassigns page ids, requiring gearDisplay references to be re-verified, and external_reload requires save=True. It omits auth/permission requirements and reversibility, so it is strong but not complete.

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

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

Purpose is front-loaded, then flag semantics are grouped efficiently with a parenthetical warning for the destructive pages behavior. The stray mention of 'strength', which is not a parameter, is a small blemish but overall it is tight and well-organized.

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 values need not be explained, and the key destructive side effects are covered. Still, for a 13-parameter mutation tool with 0% schema description coverage and no annotations, several parameters and the verify/strength relationship remain unexplained.

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 13 parameters, so the description must compensate. It explains create, remove, pages, add_pages, selected_index, selected_page, external_reload and the save coupling, but leaves exported, home_page, auto_radio_group_depth (and the referenced 'strength', which maps to no actual parameter) 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 states a specific verb set (create/modify/delete) and a precise resource (the current component's Controller), which an agent can distinguish from the read-only sibling fgui_list_controllers. It does not explicitly name an alternative sibling or scoping rule, but the mutation 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?

The description explains the operational modes (create=True, remove=True, pages replace, add_pages append, selected_index/selected_page select), which is effectively invocation guidance. However, it names no alternatives and gives no when-not-to-use or prerequisite conditions beyond the external_reload/save coupling.

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 behavioral burden and does disclose meaningful non-obvious traits: the clear-on-None semantics, partial-update behavior for pages, and the external_reload=True => requires save=True condition with a re-comparison after reopen. It stops short of describing auth/permission needs or what mutation failure looks like.

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?

Short and front-loaded: the primary action and scope come first, followed by compact per-parameter notes. Every line carries information, though the dangling 'strength' reference adds minor noise.

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 values need not be described. But for an 8-parameter mutation tool with zero annotation and zero schema-description coverage, the definition leaves the object-targeting parameters and save semantics under-specified, which an agent needs in order to call it correctly.

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

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

Schema coverage is 0%, so the description must compensate. It well documents controller, pages (id/name list plus the '0,1' comma-string form), and external_reload, and touches save indirectly, but the three object-identification parameters (object_id, object_name, object_path) go entirely unexplained. It also references a 'strength' parameter that does not exist in the schema, which is mildly confusing.

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

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

States a specific verb and resource: setting the gearDisplay linkage on an object, with the fields involved (controller + visible pages) and a version note (0.8.8+). An agent can tell what the tool changes. It does not explicitly differentiate itself from nearby siblings like fgui_set_controller or fgui_set_property, so it stops short of 5.

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

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

Gives real usage conditions for the core parameters ('controller=None/empty clears the linkage', 'omitting pages keeps existing pages'), which is useful operational guidance. However, it offers no when-to-use framing versus alternatives (set_controller, set_property, set_relation) despite a crowded sibling set, leaving selection 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, the description carries the full burden, and it does disclose meaningful traits: the version gate (0.8.8+), the advanced-group conditional that silently no-ops several fields otherwise, and the save/external_reload dependency chain. It omits mutation/reversibility framing and the fact that an open document and target object are required, keeping it below a 5.

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?

Purpose and the field inventory are front-loaded and the sentences are dense rather than padded. The trailing clause about external_reload and 'strength 标明验证强度' is cryptic and refers to a 'strength' concept absent from the schema, which costs clarity.

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

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

An output schema exists, so return values need no explanation. Still, for a 7-parameter mutation tool with a nested free-form object and zero schema descriptions, leaving object identification and the save/verify flags unexplained leaves an agent guessing on several required decisions.

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 enumerate the valid keys inside the nested `fields` object and the allowed layout values (horizontal/vertical or hz/vt), which the bare `additionalProperties: true` schema does not. But save, verify, object_id, object_name and object_path remain entirely undocumented, and the reference to a 'strength' marker matches no listed parameter.

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

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

States a specific verb and resource: modify the layout properties of a Group object, with a version qualifier (0.8.8+). This implicitly separates it from fgui_set_list_layout, but the description never names the sibling or explicitly distinguishes Group layout from list layout, so it stops short of a 5.

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

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

It surfaces real usage conditions – which fields only take effect when advanced=true, and that external_reload=True requires save=True and a document reopen to re-compare. However, it never states when to reach for this tool over fgui_set_property or fgui_set_list_layout, nor any when-not-to-use exclusion.

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 behavioral burden. It usefully discloses the version requirement, the save/external_reload dependency, and the close-reopen-then-recompare verification cycle. It does not state what happens to unlisted layout fields, whether changes are reversible, or permission requirements, leaving notable gaps 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 purpose leads, followed by a dense but useful enumeration of supported fields and trailing notes on external_reload and strength. There is minimal filler, though the field list is long enough that it could be organized more crisply.

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 values need no explanation, and the description thoroughly documents the nested 'fields' payload, which is the hard part of this tool. The main remaining gap is the undocumented object-identification and verify/save parameters, a minor omission given their conventional naming.

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 'fields' is an opaque additionalProperties object, so the enumerated field names and enum values (layout modes, selectionMode, overflow, margin format) add real value beyond the schema. But five of seven top-level parameters (save, verify, object_id, object_name, object_path) are never explained, so it only partially compensates for the coverage gap.

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

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

The description names a specific verb (修改/set) and a precise resource (List 对象的布局与滚动属性), and it contrasts naturally with the sibling fgui_set_group_layout, which targets a different container type. An agent can identify the operation without opening the schema.

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

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

The description gives a version gate (0.8.8+) and a conditional rule ('external_reload=True 需 save=True'), which is genuine usage guidance. However, it never states when to prefer this tool over fgui_set_property or fgui_set_group_layout, nor any exclusions, so guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full burden and does disclose real behavior: the mutation is recorded in an undo/redo transaction stack, save triggers a disk XML comparison, external_reload closes/reopens the document, and the response strength field (reload/disk/none) reports verification level. It still omits required permissions and failure/error behavior.

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

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

Compact and front-loaded: purpose first, then a tight sentence each for save, external_reload, and the strength response field. Little waste, though the save/external_reload clauses are dense enough to need careful reading.

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 values need not be re-explained, and the description does cover the salient transaction/verification behavior. The biggest gap is the unresolved object-identification model among three optional selectors, which an agent needs in order to call an 8-parameter mutation 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% across 8 parameters, so the description must compensate — and it only documents save and external_reload (and gestures at verify via the response 'strength'). The three mutually-exclusive object selectors (object_id/object_name/object_path), value, and property_name are left entirely unexplained, including which identifier wins when several are supplied.

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

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

States a specific verb (修改/set) and resource (白名单属性/whitelisted properties), plus a distinguishing trait — that the operation enters the Agent property undo/redo stack. It is clear what the tool does, though it never names a sibling such as fgui_set_text_style or fgui_set_list_layout to disambiguate which property-setting tool to pick.

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

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

Usage context is implied through the save/verify/external_reload mechanics (e.g. external_reload requires save=True), but there is no explicit when-to-use-vs-alternatives guidance and no statement of prerequisites such as an open document or a selected object.

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

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

With no annotations, the description carries the burden. It does disclose meaningful traits: whole-replace (destructive to existing bindings), the version requirement, and the external_reload/save coupling plus verify semantics. It omits permissions, failure behavior, and whether the change is undoable.

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?

Dense and front-loaded: the replacement scope and version come first, then the payload format, then the reload constraint. No filler sentences, though the nested brace/parenthetical formatting is hard to scan.

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 values need not be explained. However, for a 7-parameter mutation tool with 0% schema coverage, missing guidance on how the target object is identified and what save/verify do leaves a real gap.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate. It richly documents the relations item shape and sidePair direction vocabulary, but says nothing about object_id/object_name/object_path, save, or verify, leaving several parameters undocumented in both places.

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

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

States a specific verb+resource: 整体替换对象的 Relation 绑定 (whole replacement of an object's relation bindings), plus a version gate (0.8.8+). That scope word 整体 clearly signals it is not incremental, and no sibling tool covers relations, so no sibling differentiation is needed.

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

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

Gives one conditional dependency (external_reload=True requires save=True, and requires reopening the document to re-compare), but never states when to use this tool versus siblings like fgui_set_property, nor any prerequisite for identifying the target object.

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 does disclose non-obvious behavior: external_reload closes and reopens the document after saving, and the response strength field reports verification level (reload/disk/none). It still omits whether the mutation persists without save, permission needs, and 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?

Two short paragraphs, purpose front-loaded, followed by the verification semantics. Little waste, though the verification detail could be tightened.

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 values need not be explained, yet the description usefully adds the strength field meaning. However, for a 7-parameter mutation tool with a nested style object and no annotations, it fails to cover object targeting and the style payload, leaving real 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% across 7 parameters, so the description must compensate. It only explains external_reload and its dependency on save, leaving style, verify, object_id, object_name, and object_path entirely undocumented, so most parameters remain 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 and resource: setting a unified text style for TextField/RichText objects. It is clear what the tool does, but it never differentiates itself from siblings such as fgui_get_text_style or the generic fgui_set_property, so an agent must infer which one to pick.

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 guidance relative to alternatives. The only usage direction is conditional: external_reload=True requires save=True and is the only way to prove values survive a reload. That is useful parameter guidance but not tool-selection 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?

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.