GECK MCP

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

The word 'Read' makes it clear the tool is non-mutating, which is meaningful because no annotations are provided. The phrase 'from the GECK main window title' also discloses that it inspects UI state rather than reading a file directly. This is adequate for a simple read-only 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?

A single focused sentence states the action, target, and data source with no filler. It is appropriately sized for a simple 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?

The description is complete enough for the core read behavior, and the output schema exists to cover return values. However, the backend parameter is undocumented, and there is no context about prerequisites or when this tool is preferable over similar siblings, leaving a moderate completeness gap.

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

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

The schema description coverage is 0%, and the description does not mention the 'backend' parameter at all. The meaning of 'backend', valid values, or why 'win32' is the default are left entirely unexplained, so the description provides no compensatory value.

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

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

The description clearly identifies the action ('Read'), the object ('active plugin name'), and the source ('GECK main window title'). This distinguishes it from sibling tools like geck_list_plugins or geck_save_active_plugin.

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 geck_plugin_status, geck_list_plugins, or geck_save_active_plugin. With many sibling tools, the lack of any routing or exclusion is a noticeable gap.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the copy operation and destination, which implies a non-destructive read from Data and a write to the backup directory, but it does not mention overwrite behavior, whether the backup directory is created automatically, or what happens if the plugin is missing or already backed up.

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

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

The description is a single, tightly worded sentence with no filler. It front-loads the action and states source and destination economically, and every part of the sentence adds useful 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?

While the core operation is clear, the description is incomplete for a tool with three parameters, two of which are undocumented, and no annotations. There is no mention of when to use the optional parameters, what backup behavior to expect, or how this relates to the larger backup/transaction workflow implied by sibling tools.

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

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

Schema description coverage is 0%, and the description only implicitly clarifies plugin_name by referring to the .esm/.esp being copied. The optional label and game_dir parameters are completely unexplained, leaving the agent without enough information to decide whether to set them or what values they expect.

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 ('Copy') and names both the source ('Data') and destination ('MCP backup directory'), and it targets a specific resource type (.esm or .esp). This clearly distinguishes it from sibling tools like geck_save_active_plugin or geck_esp_patch_ref_position, which perform different 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?

There is no guidance on when to use this tool versus alternatives, nor any stated prerequisites or exclusions. It does not explain whether this should be run before edits, as part of a transaction, or instead of geck_save_active_plugin. The agent is left to infer the appropriate context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Find references' and lists search keys; it omits state dependencies, matching semantics, whether selection changes, or what happens when no Cell View is selected. This is minimal for a stateful tool operating on a UI selection.

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

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

The description is a single sentence with no filler and front-loads the core action and resource. It earns its place by conveying the essential purpose in compact form, even though other dimensions lack depth.

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

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

There are 5 parameters, no annotations, and only 0% schema description coverage, yet the description provides almost no operational context. The output schema helps with return values, but the meaning of backend, exact, column, and max_matches, as well as the expected UI state, is missing, making the tool hard to invoke correctly in non-obvious situations.

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?

With 0% schema description coverage, the description must explain the parameters, but it only hints that the query can be an Editor ID, Form ID, or type. It does not map those concepts to the query or column parameters, nor does it explain exact, backend, or max_matches, leaving significant ambiguity for a 5-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 action (find references), the resource (currently selected Cell View object list), and the search dimensions (Editor ID/Form ID/type). This specific resource distinguishes it from siblings like geck_esp_list_refs and geck_find_list_rows 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 phrase 'currently selected Cell View object list' implies a precondition and a general use case, but the description does not give explicit when-to-use or when-not-to-use guidance. It does not mention alternatives such as geck_esp_list_refs or geck_object_filter, so the agent must infer the appropriate 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It reveals that the tool drives Cell View's UI controls and performs a viewport/selection navigation, but it does not disclose whether the active cell changes, whether any state is modified, whether Cell View must already be open, or whether this is safe/read-only.

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, clear sentence with no redundant filler. It front-loads the tool's action and mechanism, and every word contributes to understanding.

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 four parameters, no annotations, and zero schema descriptions, the description is too thin. It lacks preconditions, coordinate semantics, behavior when coordinates are invalid, and any indication of what the Go action does beyond jumping. An output schema exists but cannot compensate for missing usage and parameter context.

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

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

Schema description coverage is 0%, so the description must add meaning. It maps 'world-space' to world_space and 'X/Y' to x/y, which is helpful. However, it does not explain coordinate units or valid ranges, and it says nothing about the optional backend 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?

The description identifies a clear action ('jump to an exterior cell') via a specific mechanism (Cell View's world-space/X/Y/Go controls), and the resource is the exterior cell. It is distinct enough from obvious siblings because it combines world space selection with navigation coordinates, though it does not explicitly name an alternative.

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

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

No guidance is given about when to use this tool versus related tools like geck_cell_set_world_space or geck_cell_select. The description does not state whether this is the first step in a workflow, whether a Cell View must already be open, or what conditions select this tool over alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention side effects, whether an existing selection is replaced, whether Cell View needs to be focused or opened, or any state changes. The minimal sentence only states the basic operation.

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

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

A single, front-loaded sentence with no filler. Every word contributes to identifying what the tool does, and the core selection key is included immediately.

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

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

For a tool with five parameters, no annotations, and 0% schema coverage, the description is too thin to fully support correct invocation. It does not explain the matching behavior, the meaning of world_space for exterior cells, or the consequences of using this tool. An output schema exists but does not compensate for the missing operational context.

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

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

Schema description coverage is 0%, so the description must compensate. It only clarifies that editor_id is the lookup key ('by Editor ID'). The other four parameters—exact, double, backend, and world_space—are left completely unexplained, leaving the agent to guess their roles.

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

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

The description states a specific action ('Select'), a specific resource ('interior/exterior cell'), a UI context ('Cell View'), and the selection key ('Editor ID'). It is clear enough to distinguish from sibling tools like geck_cell_select_ref, 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 implies that the tool is for selecting a cell by Editor ID, but it gives no guidance on when to use this tool over alternatives, no prerequisites (e.g., Cell View must be open), and no exclusions. An agent is left to infer the selection criteria from the name and sibling context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the selection action but does not explain side effects, whether it changes the current Cell View selection, how exact/double matching affects behavior, or what occurs on failure. It is not misleading, but it is behaviorally thin.

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

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

The description is a single compact sentence with no wasted words, but it is under-specified rather than appropriately concise. Important behavioral and parameter information is absent, so the brevity does not serve the agent's decision-making.

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 and return values need not be described, the tool has five parameters, no annotations, and zero schema coverage in the description. The description is too sparse to let an agent confidently invoke the tool with the correct parameter values and selection mode.

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 mentions none of the five parameters. An agent gets no help understanding the expected format of 'query', the meaning of 'exact', 'column', 'double', or 'backend', and must rely entirely on parameter names and defaults.

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

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

The description states a specific verb and resource: 'Select a reference' in the 'currently selected Cell View object list.' This clearly identifies the operation and the target context, though it does not explicitly differentiate itself from related sibling tools like geck_cell_find_refs or geck_esp_list_refs.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any conditions such as required active context or prerequisites. It only vaguely implies 'currently selected' context, leaving an agent to guess when this tool is appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It indicates a UI mutation ('Set ... combo box') but does not disclose side effects, requirements such as the Cell View being open, whether this changes the active cell, or any potential failure modes.

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. The action, target, and illustrative examples all appear in the first line, and every word contributes to understanding.

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

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

Given the lack of annotations, 0% parameter coverage, and the UI-automation nature of this tool, the description is too thin. It does not explain prerequisites, valid world-space values, backend semantics, or what happens after the combo box is set, leaving an agent to guess critical invocation details.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning to 'world_space' through examples, but 'backend' is left completely unexplained, and the expected string format for world_space is not defined beyond two examples.

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

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

The description names a specific verb ('Set'), a specific resource ('Cell View's world-space combo box'), and gives concrete examples ('Interiors or Wasteland'). This makes the tool's function immediately clear and distinguishes it from sibling tools like geck_cell_select or geck_cell_go_to_exterior.

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

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

The description does not state when to use this tool versus alternatives, nor does it mention any prerequisites or workflow context. The examples imply the kind of values, but there is no explicit guidance about when this action is appropriate or what state the GECK UI must be in.

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

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

There are no annotations, so the description carries the full burden. It does disclose that this is a read operation, which is useful, but it does not mention whether the Cell View must be active, whether a stale snapshot can be returned, or what happens when limits like max_refs and max_cells are exceeded.

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, tightly worded sentence that front-loads the operation ('Read Cell View state') and immediately lists the returned aspects. Every phrase contributes meaning and there is 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 snapshot tool with an output schema, the description adequately names the core return contents, but it leaves parameter semantics and operational context unexplained. Given no annotations and three tunable parameters, a bit more context about backend and limit behavior would make it more 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%, and the description does not explain the three parameters. The names 'max_refs' and 'max_cells' are somewhat self-explanatory, but 'backend' is ambiguous and none of the parameters are connected to the described behavior in a way that helps an agent choose sensible 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 uses a specific verb ('Read') and resource ('Cell View state') and enumerates the key contents: world space, selected cell, visible cells, and current cell references. It conveys the tool's focus clearly, though it does not explicitly contrast it with sibling snapshot tools like geck_object_snapshot.

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 instead of the many related cell and snapshot tools. The description implies a read-only inspection use case, but it does not state prerequisites, typical workflows, or exclusions, leaving the agent to infer applicability.

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, yet it only reveals the relative-to-window default. It does not disclose focus requirements, whether it moves the mouse or dispatches events, targeting via handle/title_regex, 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. It is not richly structured, but every word contributes; the main loss is from missing guidance, not wordiness.

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

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

For an 8-parameter automation tool with no annotations and no schema descriptions, this one-liner is under-specified. Even though an output schema exists, the action's targeting, button, and backend behavior 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 coverage is 0%, so the description must compensate, but it only clarifies that x/y are window-relative coordinates by default. The other six parameters, such as button, double, handle, backend, and title_regex, receive no semantic explanation beyond their names.

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

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

The verb 'Click' plus object 'coordinates' gives a clear action and target, and 'window-relative by default' defines the coordinate frame. It does not explicitly name geck_click_control, but the focus on raw coordinates rather than UI controls provides some sibling differentiation.

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

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

The description implies this is for coordinate-based clicking, especially when you have x/y positions, rather than control-based clicking. However, it gives no explicit when-to-use versus alternatives, 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?

No annotations are provided, so the description must carry the behavioral burden. It does disclose the core action—clicking a child control—and the finding strategy, but it omits important behavioral details such as whether clicks are single or double by default, which window/control context is required (handle), and what happens when lookup fails.

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. It efficiently states the action and the main selection modes, earning its length despite being incomplete in other dimensions.

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

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

This is a nine-parameter tool with no schema descriptions and no annotations, yet the description provides only a one-line summary. An agent would lack enough context to confidently set handle, backend, found_index, or title_regex, and would not know the exact click semantics or failure behavior. The output schema exists, so return-value documentation is less critical, but the input side is under-specified.

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

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

Schema description coverage is 0%, so the description must compensate for nine undocumented parameters. It maps only title, class, UIA type, and automation id to lookup criteria, leaving handle, backend, double, found_index, and title_regex unexplained, even though these are not self-evident from the schema alone.

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

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

The description gives a specific verb ('click') and resource ('child control') plus the selectors used to find it (title, class, UIA type, automation id). It is clear about what the tool targets, though it does not explicitly distinguish itself from sibling geck_click_at, which is coordinate-based.

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 use this tool versus alternatives such as geck_click_at, geck_menu_select, or geck_cell_select. The implied use is for clicking UI child controls identified by accessibility properties, but the description never states a condition or 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 must disclose behavioral traits. 'Dump' implies a read-only inspection, but the description does not explicitly state side-effect-free behavior, error cases, or limitations such as max_depth/handle dependencies. The single sentence leaves too much unstated for a tool with no annotation safety net.

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, front-loaded sentence with no filler. The essential verb, resource, and purpose are all present, so it earns its place.

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

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

While an output schema exists, the tool has four optional parameters and zero annotation context. The description does not explain how filtering or depth should be used, what handle/backend refer to, or how the result should be consumed beyond 'planning UI automation.' This is too sparse for a reliable call.

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

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

Schema description coverage is 0% and the description mentions none of the four parameters (handle, backend, max_depth, title_regex). The agent must guess their meanings and interactions entirely from names and defaults; the description adds no semantic value.

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

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

The description states a specific action ('Dump'), a clear resource ('GECK window/control tree'), and an explicit purpose ('for planning UI automation'). This distinguishes it from sibling tools like geck_list_windows or geck_screenshot.

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 gives a clear use case: collecting the window/control tree before planning UI automation. It does not explicitly name alternatives or state when not to use it, but the context is enough for an agent to select it.

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

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

With no annotations, the description must carry the burden of disclosing side effects. The verb 'check' strongly implies a read-only diagnostic, but the description does not explicitly state that nothing is modified or what happens when optional dependencies are missing. This is adequate but not deeply 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?

One single-purpose sentence with no filler; the core action and target are front-loaded. It earns its place and could not be shortened without losing information.

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

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

The tool is simple and has an output schema, which covers return-value details, but the description omits how the optional game_dir parameter is used and gives no usage context. An agent cannot confidently choose arguments or determine when this diagnostic is appropriate.

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

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

The input schema has 0% description coverage and the only parameter, game_dir, is not mentioned in the tool description at all. The description adds no meaning beyond the schema's title, leaving the agent to guess how game_dir affects the path checks.

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 'Check paths and optional dependencies for this GECK MCP server' states a specific action and a specific resource, and it is clearly distinct from the sibling tools, none of which are diagnostic. It stops short of a 5 because 'paths' is somewhat underspecified and it does not explicitly contrast with related tools.

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

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

No guidance is given for when to invoke geck_doctor versus any of the 40+ sibling tools. The description implies a health-check use case but does not state prerequisites, when to prefer it, or what conditions warrant running it.

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

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

The description does disclose an important behavioral trait: the deletion happens 'directly from an .esp/.esm file', implying an on-disk modification rather than a temporary in-editor change, and it mentions group-size maintenance. However, with no annotations, it still omits safety-relevant details such as whether the deletion is reversible, whether backup is involved, or how the file state changes beyond the deletion.

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. The main action and the key side effect are stated immediately, and every word adds useful information.

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

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

For a destructive file-modifying tool with four parameters and no annotations, the description is too thin. It does not explain backup behavior, which plugin is modified, or how this relates to the active plugin and transaction/save workflow. The presence of an output schema reduces the need to describe return values, but the operational context is still incomplete.

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

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

Schema description coverage is 0%, and the description does not compensate by explaining ref_form_ids, plugin_name, game_dir, or backup. The only implied parameter meaning is that some references are deleted, but the agent gets no help understanding how backup, target plugin, or game directory affect the operation.

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

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

The description clearly states the action ('Delete placed records') and the resource ('.esp/.esm file'), and adds a specific internal detail ('update group sizes'). It is clear enough to distinguish from listing or patching refs, but it does not explicitly contrast with the closely related sibling geck_esp_delete_refs_by_base.

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

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

There is no guidance on when to use this tool versus alternatives such as geck_esp_delete_refs_by_base or transaction-based workflows. The intended context is only implied by the verb 'Delete', with no exclusions, prerequisites, or warnings about when not to call it.

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

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

With no annotations available, the description carries the full burden of behavioral disclosure. It does reveal the central behavior: matching is based on the base FormID, not the reference's own FormID, and matching records are deleted. However, it does not mention whether the deletion is permanent, whether backup=true creates a restore point, or how plugin_name scopes the deletion, which are important for a destructive operation.

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

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

The description is a single compact sentence with no filler. It front-loads the action and object, then states the matching condition efficiently. Every word contributes to understanding what the tool does.

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 four parameters and no annotations, the description is incomplete. It omits the purpose of backup, which plugin is affected by plugin_name, and why game_dir is needed. The presence of an output schema covers return-value documentation, but the side-effect model and input semantics are not sufficiently explained for confident invocation.

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

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

Schema description coverage is 0%, so the description must clarify the parameters. It only adds meaning to base_form_ids by connecting it to 'NAME/base FormID'. The backup, game_dir, and plugin_name parameters are not explained at all, leaving an agent to guess their roles from names and default values alone.

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

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

The description clearly states the action ('Delete'), the resource ('placed records'), and the exact selection criterion (NAME/base FormID matches one of the given base IDs). This makes the tool easy to distinguish from the sibling geck_esp_delete_refs, which is not explicitly scoped to base FormIDs. The purpose is specific and immediately recognizable.

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

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

The description implies this tool should be used when the goal is to remove all placed instances matching particular base FormIDs. However, it does not explicitly say when to choose this over geck_esp_delete_refs or another reference-editing tool, and it provides no exclusions or prerequisites. The usage context is inferable but not stated.

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

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

With no annotations provided, the description carries the burden of disclosing behavior. The word 'Read' clearly signals a non-mutating operation, and 'from an .esp/.esm file' indicates it works on file data rather than live editor state. It does not mention prerequisites or side effects, but the core behavior is sufficiently transparent for a read-only listing tool.

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

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

The description is a single, front-loaded sentence with no filler. It communicates operation, record type, and file scope directly, making every word useful.

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

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

The output schema covers the return shape, and the operation is simple, so the description is adequate for a basic invocation. However, it leaves game_dir ambiguous and provides no guidance for selecting this tool among several ref-related siblings, creating clear 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%, and the description does not explain either parameter. 'from an .esp/.esm file' indirectly identifies plugin_name as the target plugin, but game_dir remains completely unexplained, leaving the agent to rely on parameter names and defaults.

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

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

The description states a specific verb ('Read'), a precise resource ('placed REFR/ACHR/ACRE records'), and a clear scope ('.esp/.esm file'). This distinguishes it from sibling tools like geck_esp_nearby_refs or geck_cell_find_refs, which operate on different data sources.

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 '.esp/.esm file' qualifier implies a file-based use case, so an agent can infer this reads references directly from a plugin file. However, there is no explicit guidance on when to choose this tool over alternatives such as geck_esp_nearby_refs or geck_cell_find_refs.

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

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

There are no annotations, so the description carries the burden. 'Find' implies a read-only query and 'near a coordinate' indicates spatial filtering, but the description doesn't state whether this operates on a loaded plugin, what coordinate space is used, or whether any state changes occur. It is not misleading, just minimal.

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

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

A single compact sentence with no filler. The key subject, verb, and spatial scoping are all present 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?

Despite an output schema being present, the description fails to provide enough operational context for an agent to invoke this correctly: coordinate system, radius behavior, plugin selection semantics, and relation to geo/cell variants are all absent. For a 7-parameter tool with no annotations, this is a significant completeness gap.

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

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

Schema description coverage is 0%, and the description only loosely maps to parameters: 'near a coordinate' hints at x/y/z, and 'in a plugin' hints at plugin_name. It does not explain radius units/semantics, cell_form_id, game_dir, or how the defaults apply, leaving most of the 7 parameters underspecified.

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 ('Find') and resource ('placed records in a plugin near a coordinate'), making the core function clear. It doesn't explicitly contrast with nearby siblings like geck_esp_list_refs or geck_cell_find_refs, so it stops short of a perfect differentiation.

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

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

No guidance is provided about when to choose this tool over alternatives such as geck_cell_find_refs or geck_esp_list_refs. The intended use is only implied by the tool name and one-line description, with no exclusions or context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The GECK-closed note usefully hints this edits the plugin file directly rather than driving the editor UI, but it never states that the operation mutates the on-disk ESP, whether it is destructive/reversible, whether a backup is made (a backup parameter exists), or what happens if GECK actually is running. For a mutating tool this is a significant gap.

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

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

A single 13-word sentence with the primary action front-loaded ('Patch a placed record with GECK closed') followed by the highest-risk parameter detail. No filler or redundancy; every clause carries information.

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

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

For a 10-parameter, 4-required mutation tool with no annotations and zero schema coverage, the description is under-specified. It omits coordinate/unit context, how the target plugin is resolved (plugin_name default is a test ESP), safety/backup expectations, and the relationship to the GECK workflow. An output schema exists, so return values are excused, but the operational context needed to call this safely is not.

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?

With 0% schema description coverage, the description's 'Rotation is in radians; omitted axes are preserved' is genuinely valuable: it prevents radians-vs-degrees errors and clarifies that null/omitted rot_* values mean 'keep current rotation', which the schema's null defaults do not convey. However, x/y/z units, the format of ref_form_id, and the meanings of backup, game_dir, and plugin_name are left entirely undocumented, so compensation is only partial.

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

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

The description names a specific verb ('patch'), a resource ('placed record'), and a condition ('with GECK closed'), which distinguishes it from siblings like geck_esp_patch_ref_to_status_bar and geck_esp_delete_refs. However, the fact that the tool actually sets position and optional rotation is only implied by the tool name and the rotation note, and 'patch' is left as domain jargon rather than spelled out as 'update position/rotation of a reference'.

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?

'With GECK closed' is a precondition, not guidance about choosing this tool. The description never states when to prefer this over sibling patching tools (geck_esp_patch_ref_to_status_bar, geck_esp_patch_ref_to_status_bar_offset), nor any exclusions. An agent would have to infer the intended use case from a 45-tool sibling list.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states the tool never writes while GECK is open and that it returns applied=false, giving the agent a concrete behavioral contract. It does not, however, explain whether any state is captured externally or whether the tool has side effects on planning data.

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

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

The description is a single, tightly worded sentence that front-loads the most important usage qualifier ('Legacy planning only') and packs key behavioral facts (no writes, returns applied=false) into minimal space. Every clause earns its place.

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

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

Despite having an output schema, the tool has five parameters, no annotations, and zero schema descriptions. The one-line description leaves the agent without enough context to select and populate parameters correctly or to understand what 'deferred patch arguments' means in practice. It is too sparse for a tool of this complexity.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the parameters. It does not mention ref_form_id, plugin_name, backup, backend, or game_dir at all. The tool name and 'capture deferred patch arguments' hint at ref_form_id, but no actual parameter semantics are provided.

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 'capture' with a clear resource ('deferred patch arguments') and states the tool's intentional no-write behavior. It identifies itself as 'Legacy planning only' and mentions the return value, which helps distinguish it from actual patch-application tools. However, it does not explicitly reference status-bar functionality or differentiate itself from the closely named sibling geck_esp_patch_ref_to_status_bar_offset.

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 'Legacy planning only' provides clear context for when this tool is appropriate: planning and capturing deferred arguments rather than executing a live patch. 'Never writes while GECK is open' implies a strong when-not-to-use condition but does not name alternative tools or explicitly state what to use instead.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It explicitly states the critical behavior: it does not write, and it returns applied=false. This is unusually transparent for a no-op tool and prevents an agent from mistakenly expecting a 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?

The entire description is one compact sentence that front-loads the most important signal ('Legacy planning only') and then states the key behavioral consequence. Every phrase earns its place, and there is no wasted or repetitive text.

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

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

Although the no-op behavior is clear and an output schema exists, the tool has 13 parameters, no annotations, and zero schema description coverage. The description does not explain what 'deferred patch arguments' are, which parameters are meaningful in planning mode, or how the agent should set them. An agent could call this tool but would not fully understand the intended planning workflow.

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

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

Schema description coverage is 0%, and the description only mentions 'patch arguments plus offsets' as a collective group. It does not explain any of the 13 individual parameters, their relationships, or which ones matter for the deferred planning behavior. This is insufficient given the schema's total lack of descriptive content.

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 behavior: capture deferred patch arguments plus offsets and return applied=false without writing. It clearly signals this is a legacy planning-only variant, which differentiates it from the active patch tool among the siblings, though it never names the alternative and 'capture' remains slightly ambiguous.

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?

'Legacy planning only' implies this should be used solely for planning and not for applying real patches, but the description does not explicitly say when not to use it or which sibling should be used instead. The usage context is implied rather than stated with clear alternatives or exclusions.

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

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

No annotations are provided, so the description bears the full burden of behavioral disclosure. 'Find' implies a read-only search operation and the hint about Editor ID/Form ID is useful, but the description does not disclose matching semantics, case sensitivity, exact-match behavior, what happens with zero or multiple matches, or whether any state changes occur.

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 tight sentence with no filler or redundancy. However, it is under-specified given the tool's parameter complexity and the close sibling relationships, 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?

For a tool with 8 parameters, no schema descriptions, no annotations, and a large sibling set that includes geck_list_view_rows, the description is incomplete. It leaves parameter semantics, matching behavior, and tool-selection guidance implicit. The presence of an output schema covers return values, but not enough else.

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 there are 8 parameters. The description only hints at what 'query' should contain ('usually Editor ID or Form ID') but does not explain exact, column, handle, backend, list_index, max_matches, or title_regex. An agent cannot determine the meaning and interaction of these parameters from the description.

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

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

The description clearly identifies a specific verb ('Find'), a resource ('rows in a GECK ListView'), and the search basis ('by text, usually Editor ID or Form ID'). It is easy to understand what the tool does, though it does not explicitly position itself against the close sibling geck_list_view_rows.

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 intended use is implied: use this tool when you need to locate rows in a ListView by text. However, the description gives no explicit guidance about when not to use it or how it relates to geck_list_view_rows, which appears to be a closely related alternative.

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 only states the focus action and does not explain what happens if the window or dialog is missing, whether focus is switched as a side effect, or whether the backend choice affects behavior.

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

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

The description is a single, compact sentence with no filler or redundant phrasing. It is concise, though the brevity comes at the cost of useful context.

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

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

For a tool with three optional parameters and no annotations, the description is materially incomplete. It does not state how to target a specific window, what the backend parameter does, or what the output represents, leaving the agent to guess.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not explain any of the three parameters. The phrase 'matching dialog' weakly hints at title_regex, but handle, backend, and how they combine remain undefined.

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 ('focus') and identifies the resource ('GECK main window or a matching dialog'), making the core action clear. It does not, however, differentiate it from sibling tools like geck_list_windows or geck_send_keys, so it misses the top score.

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 use this tool versus alternatives. It does not mention prerequisites such as first listing windows to obtain a handle, nor does it say whether it should precede key-sending or menu actions.

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 does disclose the core behavior: launching GECK and optionally using fose_loader.exe -editor. However, it does not mention whether the launch blocks, what happens on failure, side effects on the environment, or whether the call returns process information.

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

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

A single sentence with no filler, front-loading the primary action 'Launch GECK' and then adding the FOSE variant concisely. 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?

The description covers the main launch modes and the output schema exists, so return values are not a concern. However, with three parameters and 0% schema coverage, the missing semantics for game_dir and extra_args leave the definition incomplete for anything beyond a default launch.

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

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

Schema description coverage is 0%, so the description must compensate, but it only loosely implies the via_fose parameter through 'with FOSE via fose_loader.exe -editor.' It provides no explanation of game_dir or extra_args, leaving the agent without enough guidance for non-default calls.

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 begins with the specific verb 'Launch' and identifies the resource, GECK, including a distinct FOSE mode via fose_loader.exe -editor. This clearly differentiates geck_launch from all sibling tools, none of which are launch 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 intended use is obvious: use this tool to start GECK, either normally or with FOSE. It does not explicitly name alternatives or exclusion criteria, but among the siblings this is the only launch operation, so the context is clear.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'List' clearly implies a read-only operation, but the description does not mention how the optional parameters affect behavior, whether BSA files are included by default, or how a null game_dir is resolved.

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. Every word earns its place, and the verb and object are immediately clear.

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

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

This is a low-complexity tool and an output schema exists, so return-value coverage is not a concern. However, the description leaves ambiguity around the optional parameters and does not distinguish this listing operation from load-order or plugin-status operations, making it 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 description coverage is 0%, so the description must compensate for the two parameters, but it does not explain game_dir or include_bsa. The parameter names and defaults provide some hint, but the description adds no semantic meaning beyond the tool's overall purpose.

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

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

The description uses a specific verb ('List') and a precise resource ('plugin files in the Fallout 3 Data folder'). It clearly distinguishes the tool from siblings like geck_list_windows, geck_list_processes, and geck_read_load_order, which focus on different resources or aspects.

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 prefer this tool over related siblings such as geck_read_load_order or geck_plugin_status. The use case is only implicit in the verb 'List', with no exclusions, prerequisites, or alternative routing.

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

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

With no annotations provided, the description carries the behavioral burden. The verb 'List' conveys a read-only operation and implies no side effects, but the description does not disclose how processes are matched or whether GECK/FOSE must already 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 front-loaded sentence with no filler or redundancy; every word contributes to the core purpose.

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

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

Though an output schema exists and removes the need to document return values, the description remains incomplete for actual invocation: game_dir is unexplained, no usage guidance is given, and the intended scope of 'FOSE-related processes' is ambiguous.

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 game_dir. The schema only shows it is an optional string defaulting to null; the description adds no meaning about how the game directory affects process listing.

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 action and resource: list processes related to GECK and FOSE. This distinguishes it from sibling list tools such as geck_list_plugins and geck_list_windows, though the phrase 'FOSE-related' is not expanded.

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 indication of when to use this tool instead of alternatives like geck_doctor, geck_launch, or the other list tools, and no exclusions or prerequisites are stated.

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

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

No annotations are present, so the description must carry the full burden of behavioral disclosure. 'Read' implies a non-mutating operation, but it does not explain how the target window is resolved, how the handle may be omitted, whether this is safe to call on any ListView, or how errors are surfaced.

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 a clear verb and object. It contains no filler or redundant phrases, making it as concise as possible.

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

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

Despite the presence of an output schema, the tool has seven undocumented parameters, no annotations, and no usage context. The description leaves an agent without enough information to know when to call it, how to choose parameters, or what relationship this tool has to the rest of the GECK workflow.

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

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

Schema description coverage is 0%, and the description adds nothing about any of the seven parameters. An agent receives no meaning for handle, list_index, max_rows, title_regex, backend, start_row, or max_columns beyond their bare names and defaults.

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

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

The description names a specific verb ('Read') and a precise resource ('rows from a Win32 ListView in a GECK window or dialog'), so an agent can tell what the tool acts on. However, it does not explicitly distinguish itself from sibling tools like geck_find_list_rows, which likely performs a related row-reading 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?

There is no guidance on when to use this tool, what prerequisites are needed (e.g., a valid window handle), or when to prefer an alternative such as geck_find_list_rows or geck_control_tree. The description only states the action itself.

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

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

There are no annotations, so the description carries the burden. It does disclose the read-only enumerative behavior and the constraint that only top-level windows visible to pywinauto are listed. However, it does not mention backend behavior, window visibility nuances, or other operational caveats, leaving some behavioral ambiguity.

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 with no filler. It front-loads the core action and scope and earns its place entirely.

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 enumeration tool with an output schema, a very short description may be acceptable. Still, the lack of annotation coverage and unexplained optional parameters means an agent may not know which backend to use or how the title filter behaves, so the context is 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 description coverage is 0%, and the description adds no parameter context. The names 'backend' and 'title_filter' give some clue, but the accepted backend values and how title_filter matches windows are not explained. The description should have compensated for the schema's lack of descriptions but does not.

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

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

The description clearly states 'List top-level desktop windows visible to pywinauto', which identifies the action, resource, and scope. It is specific enough to distinguish from process-listing and focus-window siblings, though it does not explicitly contrast with closer window-related tools like control_tree or focus_window.

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 offers no guidance about when to choose this tool over alternatives such as geck_control_tree, geck_focus_window, or geck_list_processes. There is no mention of use cases, prerequisites, or when not to use it.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Select a GECK menu path' and gives format examples; it does not mention whether this opens dialogs, triggers side effects, requires GECK focus, or what happens on failure.

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 illustrative examples and no wasted words. It is front-loaded with the core action and gives immediately usable input formats.

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 UI automation tool with four parameters and no annotations, this description is too thin. It lacks usage context, behavioral expectations, and parameter details, even though an output schema exists; selecting a menu path often has important state and timing implications.

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

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

Schema description coverage is 0%, so the description must explain parameters. It partially explains menu_path with format examples, but handle, backend, and title_regex remain undocumented and their purpose is not inferable from the description.

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

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

The description clearly states the tool's action: selecting a GECK menu path, with concrete examples ('File->Data...' or ['File', 'Save']). This is specific enough to distinguish it from generic input/click tools, though it does not explicitly name a sibling alternative.

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

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

No guidance is given about when to use this tool versus alternatives like geck_send_keys, geck_click_control, or geck_open_data_dialog. The examples imply the input format but do not describe the intended scenario or list any exclusions.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It mentions the mutating action ('Set') and the returned rows, but does not disclose side effects, whether the filter persists, UI state impacts, or possible error conditions.

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

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

The description is a single, direct sentence with no filler or redundant wording. It front-loads the action and clearly states the result, making it easy to parse quickly.

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 the return format is covered elsewhere. However, the description lacks usage context, side-effect warnings, and parameter details for 'backend', leaving gaps for a tool that mutates UI state.

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

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

Schema description coverage is 0%, and the description only hints that 'text' is the filter value via 'Filter field'. The 'backend' parameter is completely unexplained, and there is no detail about formats, defaults, or allowed values beyond the raw schema.

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

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

The description states a clear action ('Set Object Window's Filter field') and a clear output ('return the filtered rows'), tied to a specific resource. It does not explicitly differentiate from sibling list/row tools such as geck_list_view_rows or geck_find_list_rows, but the 'Object Window' scope provides enough clarity.

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

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

There is no guidance on when to use this tool versus alternatives, nor any mention of prerequisites like having the Object Window open or focused. The sentence implies only a basic operation, leaving the agent to infer the appropriate context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals only that the tool may select or open a record, but it does not explain matching behavior, side effects on the Object Window UI, backend selection, or what 'double' does despite the presence of these behavioral parameters.

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 redundancy. It is concise and easy to parse, though its brevity leaves out important behavioral and parameter details.

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 four parameters, no annotations, and a sibling set with many related selection tools, the description is too sparse to provide complete guidance. The output schema exists, but that does not compensate for missing parameter semantics or usage context.

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

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

Schema description coverage is 0%, so the description must compensate, but it only clarifies the editor_id parameter. The exact, double, and backend parameters remain unexplained, and the phrase 'optionally open' only weakly hints at the double parameter without specifying its role.

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

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

The description states a clear action ('Select or optionally open') on a specific resource ('current Object Window record') and identifies the lookup key ('by Editor ID'). It is specific enough to distinguish the tool from at least some siblings like geck_cell_select_ref, though it does not explicitly delineate all sibling relationships.

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 explicit guidance about when to use this tool versus alternatives such as geck_object_filter or geck_cell_select_ref. The intended use is only implied by the action and resource, with no mention of exclusions, prerequisites, or when 'optionally open' should be chosen.

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

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

No annotations exist, so the description carries the full burden of behavioral disclosure. The verb 'Read' and the word 'snapshot' weakly imply a non-mutating operation, but the description does not state whether it refreshes the window, whether it is side-effect free, whether the window must exist, or how max_rows affects the capture. This is thin coverage for a tool with no annotation safety signals.

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

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

One short sentence with no wasted words, and the core action is front-loaded. This is appropriately concise for a simple read operation, though the brevity borders on under-specification, which is more appropriately penalized in other dimensions.

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

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

For a tool with no annotations, 0% schema parameter coverage, and many similar siblings, the description should provide substantially more context. It omits what backend means, what max_rows caps, whether the Object Window must be visible, and how this differs from geck_list_view_rows or geck_find_list_rows. The presence of an output schema reduces the need to describe return values, but it does not compensate for these gaps.

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

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

Schema description coverage is 0%, so both parameters (backend, max_rows) are undocumented in the schema and the description must compensate. The description explains neither: 'backend' with default 'win32' is cryptic without context, and 'max_rows' is intuitive by name but its relationship to snapshot behavior is unstated. The description adds no parameter meaning beyond the property names.

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

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

The phrase 'Read the current Object Window list rows' names a specific verb ('read'), resource ('Object Window'), and scope ('list rows'), so an agent can tell this is a data-retrieval tool. However, it does not distinguish itself from overlapping siblings like geck_list_view_rows or geck_cell_view_snapshot, so the differentiation work is left to the agent.

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, no mention of prerequisites (e.g., whether the Object Window must be open), and no exclusions. With multiple siblings that read list rows or take snapshots, the agent gets zero routing help.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only says the dialog is opened. It does not mention potential blocking behavior, focus changes, what happens if the dialog is already open, or any side effects related to the GUI session.

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

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

The description is a single, direct sentence with no filler words. The action and target are front-loaded, making it easy to scan and quick to parse.

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

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

The description is too thin for a tool with three undocumented optional parameters and no annotation support. While an output schema may cover the return shape, the invocation context, parameter behavior, and operational side effects are left 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%, and the description provides no meaning for the three parameters: handle, backend, and title_regex. An agent receiving this tool definition has no way to know what values to pass or why they matter.

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 identifies a specific action ('Open') and a specific resource ('GECK's File > Data dialog'), which clearly distinguishes it from most sibling tools at a glance. It does not elaborate on what the Data dialog is for, but the resource is concrete enough for practical use.

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 use this tool versus alternatives such as geck_menu_select or geck_list_plugins. The description only states what the tool does, leaving the agent to infer the appropriate context from the sibling list.

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

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

With no annotations provided, the description carries the full burden. 'Dry-run' usefully communicates a non-destructive, planning behavior, and 'from GECK's status-bar coordinate' indicates the input source. However, it does not disclose whether GECK must be running, how failures surface, or whether any UI interaction occurs, so behavioral transparency is only partially addressed.

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. It communicates the core operation efficiently, though some critical explanatory content is missing, which keeps it from a perfect score.

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

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

For a 9-parameter tool with no annotations and only a terse one-line description, the context is insufficient. An agent cannot fully determine when to invoke this tool, how parameters like use_status_rotation or object_kind affect the plan, or what behavioral guarantees 'dry-run' provides.

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

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

Schema description coverage is 0%, so the description must compensate, but it only generically references 'offsets' and 'coordinate plus offsets.' It does not explain rot_x/y/z, use_status_rotation, object_kind, or backend, leaving most of the 9 parameters semantically unexplained despite clear schema gaps.

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

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

The description clearly identifies a specific operation—computing a dry-run placement target from the GECK status-bar coordinate plus offsets—and the name reinforces the 'plan' aspect, distinguishing it from patch-style siblings. It doesn't explicitly name a sibling or contrast itself, but 'Dry-run' signals a planning operation rather than a modification.

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 'Dry-run' implies the tool should be used to preview a placement before actually applying changes, especially given siblings like geck_esp_patch_ref_to_status_bar_offset. However, there is no explicit statement of when to use this tool versus the patch or report siblings, leaving the intended context 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 full responsibility for behavioral disclosure. 'Assess' weakly implies a read-only analysis, and the cell_form_id restriction adds one constraint, but the description does not disclose what the report contains, what prerequisites exist, whether the active plugin matters, or what 'saved placed records' refers to.

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 words. It states the main action and the key constraint efficiently. Every word earns its place.

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

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

Given six parameters, zero schema description coverage, and no annotations, the description is too thin to allow reliable invocation. It addresses only cell_form_id, leaving the purpose of suspicious_z_delta, suspicious_distance, game_dir, and plugin_name entirely unexplained. The output schema helps for return values, but not for input semantics or behavioral context.

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

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

Schema description coverage is 0%, so the description should compensate by explaining parameters. It only clarifies that cell_form_id acts as an anchor restriction, and even calls it 'required' despite the schema listing it as optional with a null default. The other five parameters (backend, game_dir, plugin_name, suspicious_z_delta, suspicious_distance) are given no semantic context in the description.

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

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

The description uses the specific verb 'assess' and identifies the resource ('saved placed records against the status bar'), which clearly distinguishes it from planning or patching tools. The phrase 'restricted to the required anchor cell_form_id' adds scope. However, the meaning of 'status bar' and 'saved placed records' is assumed rather than explained.

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

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

The description implies the tool is used for assessing placement records within a specific cell, and the cell_form_id restriction gives some context. It does not explicitly state when to prefer this tool over alternatives like geck_esp_patch_ref_to_status_bar or geck_placement_plan_from_status_bar, nor does it give exclusion criteria.

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

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

With no annotations, the description is the only behavioral signal, but it only states the intended action and outcome. It does not disclose that this is a UI-automation drag operation, that it mutates the active plugin, or what happens with dry_run, coordinates, or failure cases.

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

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

The description is a single efficient sentence with the action and outcome front-loaded and no filler. It is concise, though the brevity sacrifices parameter and prerequisite 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 six-parameter UI-automation tool with no annotations and no schema descriptions, this one-line description is incomplete. It omits preconditions (active plugin, loaded render window), coordinate semantics, and how the operation relates to the transaction/save workflow hinted at by sibling tools.

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

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

Schema description coverage is 0%, and the description mentions none of the six parameters. The required editor_id, drop_x_ratio/drop_y_ratio, render_title_regex, backend, and dry_run all remain unexplained, so an agent cannot confidently select or fill the parameters based on this text.

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 concrete action ('Drag an Object Window record into the active Render Window') and the result ('create a placed reference'), so the tool's core purpose is clear. It does not explicitly contrast with placement-adjacent siblings like geck_esp_patch_ref_position or geck_placement_report, but the drag-and-drop metaphor is distinctive.

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

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

No when-to-use guidance is given beyond the implicit requirement of an active Render Window. There are no alternatives, exclusions, or preconditions listed, and with more than 45 sibling tools an agent gets little help choosing this over placement/reporting siblings.

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

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

There are no annotations, so the description carries the full burden of disclosing behavior. It does disclose the potentially mutating backup side effect, but it does not explain what creating a backup entails, whether it can overwrite existing backups, or whether the operation affects the Data directory in other ways.

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-formed sentence with no filler. The primary purpose is front-loaded, and the optional backup behavior is clearly appended in a low-cost 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?

The tool has an output schema, so the return value does not need explaining, but the description still omits important context: what game_dir does, how backup naming or overwrite behavior works, and what happens when no plugin is found. With no annotations and no parameter documentation, this is not complete enough for an agent to use all parameters confidently.

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 three undocumented parameters. It partially maps to 'backup' and suggests plugin_name refers to an .esp/.esm in Data, but it never names or explains game_dir, leaving a meaningful parameter 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 clearly states the action ('Check whether') and the resource ('.esp/.esm exists in Data'), and adds the optional backup behavior. It is specific enough to distinguish from list-style siblings like geck_list_plugins, though it does not name any alternative directly.

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 'Check whether an .esp/.esm exists in Data' implies the primary use case: verifying plugin presence before other operations. However, there is no explicit guidance about when to prefer this over geck_list_plugins or geck_backup_plugin, and no mention of prerequisites or side conditions.

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

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

With no annotations, the description carries the full burden. 'Read' explicitly signals a non-destructive operation, which is useful, but the description does not disclose behavior when game_dir is omitted, what happens if plugins.txt is missing, or whether any resolution/filtering is applied.

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. Every word contributes to identifying the tool's purpose.

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

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

This is a simple one-parameter tool with an output schema present, so return-value documentation is not necessary. However, the description lacks parameter semantics and any usage routing, leaving enough gaps that the definition is only minimally viable for correct invocation.

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

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

The schema has one optional game_dir parameter with 0% description coverage, and the description does not mention it at all. An agent must infer that game_dir indicates the game installation directory and cannot know the meaning of the default null value.

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

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

The description uses a specific verb ('Read') and resource ('Fallout 3 plugins.txt load order'), clearly identifying the artifact being accessed. It also differentiates itself from the sibling geck_write_load_order by implying a read-only counterpart.

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

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

There is no guidance on when to use this tool versus alternatives like geck_list_plugins or geck_write_load_order. The read verb weakly implies a query context, but no explicit exclusions or selection criteria are provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal the mechanism (menu command File > Save) and that it returns plugin status, but it does not mention potential side effects (saving is inherently destructive to any unsaved changes), prerequisites (active plugin must exist), configuration accepted (wait_seconds), or failure behavior. It 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 sentence, front-loaded with the main verb, and contains no wasted words. It conveys the essential action and result in a clear, efficient manner.

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

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

The description covers the primary action and return value, and an output schema exists, so return details need not be repeated. However, the complete lack of parameter semantics and minimal usage guidance means the description is not fully self-sufficient. An agent could invoke the tool with defaults, but would struggle to configure behavior intentionally.

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 compensate by explaining any of the three parameters (backend, game_dir, wait_seconds). The agent is left to infer semantics from names and defaults alone, which is insufficient for customizing invocation. This is a significant gap for a tool with undocumented parameters.

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

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

The description states a specific verb ('Save'), resource ('active GECK plugin'), method ('through File > Save'), and return value ('plugin status'). This clearly distinguishes it from sibling tools like geck_plugin_status (which reads status) and geck_backup_plugin (which creates backups rather than saving).

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 makes the basic use case obvious—save the active plugin—but does not provide any explicit guidance on when to choose this tool over alternatives, nor does it mention exclusions or prerequisites. Usage context is implied rather than stated, so an agent might not know when to prefer this over backup or transaction tools.

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

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

With no annotations, the description carries the behavioral burden. It discloses the output format and that the operation targets a GECK window or dialog, which implies a read-only capture. However, it does not mention whether the PNG is written to disk, how file naming or overwriting works, or failure behavior when no matching window is found.

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

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

The description is a single concise sentence with no filler. It front-loads the action and target, and every word contributes information.

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

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

For a tool with five optional parameters and no annotations, the description is too thin to support correct invocation. It lacks parameter meaning, usage context, and behavioral constraints beyond the basic capture action.

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

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

Schema description coverage is 0%, and the description adds no meaning to the five parameters: handle, backend, game_dir, file_name, and title_regex. An agent is left to infer semantics solely from parameter names.

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

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

The description states a clear verb and resource: capture a screenshot of a GECK window or dialog, and it specifies the PNG output format. It does not explicitly distinguish itself from sibling capture tools like geck_cell_view_snapshot or geck_object_snapshot.

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 use this tool versus sibling snapshot tools, nor what prerequisites are needed such as a running GECK instance or an active window. The usage is only implied by the purpose statement.

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 disclosure burden. It clearly states the action (sending a pywinauto key sequence) and gives syntax examples, but it does not disclose side effects such as triggering menu commands, potential window focus changes, or that certain key sequences like %{F4} could close GECK.

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

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

The description is a single efficient sentence with useful examples and no filler. It is appropriately short, though it could earn a 5 by adding a bit more structure around targeting or parameters.

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

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

This tool has 6 parameters, no schema coverage, and no annotations, yet the description only covers the keys parameter obliquely. It omits how the target window is selected or prioritized, how pause and focus behave, and what the output represents, making it incomplete for safe 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?

Schema coverage is 0%, so the description must compensate. It adds meaning for only the 'keys' parameter through concrete syntax examples, but says nothing about focus, pause, handle, backend, or title_regex, all of which remain 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 uses a specific verb and resource: 'Send a pywinauto key sequence to GECK' with concrete examples ('^s, %{F4}, or {ENTER}'). This clearly distinguishes it from sibling tools like click_at or menu_select, which handle different input mechanisms.

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 keyboard shortcuts or key sequences sent to GECK, and the examples help. However, it provides no explicit guidance on when to prefer this over alternatives such as menu_select or click_at, nor does it state any exclusions or conditions.

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

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

There are no annotations, so the description carries the behavioral burden. The verb 'Read' makes the non-mutating nature clear, and 'when available' usefully signals that selected-object coordinates are conditional. However, it does not mention prerequisites such as GECK needing to be running, or what happens when no coordinates are available.

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 of about 16 words with no filler. It front-loads the verb and resource, then adds the conditional coordinate detail. Every phrase contributes to understanding 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?

The tool is simple and an output schema exists, so return-value details do not need to be in the description. However, the overall context is incomplete because backend parameter semantics are unexplained and there is no guidance on when to prefer this over sibling status-bar-related tools.

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

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

The schema has one optional backend parameter with a default of 'win32' and 0% schema description coverage. The description does not explain what backend means or what values are acceptable, so it fails to compensate for the low coverage. The impact is lessened because the parameter is optional with a default, but the semantics are still 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 uses a specific verb and resource: 'Read GECK's bottom status bar', and adds meaningful scope with 'including selected object coordinates when available'. It is distinguishable from the mutation/planning siblings that consume the status bar, 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 about when to use this tool versus related siblings like geck_placement_plan_from_status_bar or geck_esp_patch_ref_to_status_bar. Usage is only implied as 'need current status bar info', with no exclusions or alternative routing.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, but it only says 'Read.' It does not explain how 'known' logs are resolved, how game_dir affects file lookup, or what happens when a log is missing. The scope constraint 'known' is useful but not elaborated.

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 redundancy. It is concise and easy to parse, though the brevity leaves out important behavioral and parameter detail that is penalized in other dimensions.

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

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

For a tool with three optional parameters, no annotations, and zero schema description coverage, this one-sentence description is too thin for reliable invocation. The presence of an output schema may document return values, but the description still omits valid log_name choices and the meaning of game_dir.

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

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

Schema description coverage is 0%, and the description does not explain any of the three parameters: lines, game_dir, or log_name. An agent must rely entirely on parameter names and defaults, with no indication of valid log names or path behavior. This is a substantial gap with no compensation from the description.

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

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

The description uses the specific verb 'Read' and identifies a clear resource: the tail of a GECK or FOSE log file. It distinguishes this tool from sibling tools that focus on plugins, UI interaction, or cell editing. The qualifier 'known' suggests a scoped set of supported log files, which adds useful specificity.

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

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

The description gives no guidance about when to use this tool versus alternatives, what workflow it belongs to, or any prerequisites. It does not mention exclusions or related logging/diagnostic tools, so an agent must infer the intended use from the tool name alone.

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

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

With no annotations, the description must carry behavioral disclosure. It discloses the main effect (creating a rollback point) and the safe timing, but does not explain the transaction lifecycle, what state is captured, how the transaction appears in geck_transaction_list, or what side effects occur beyond creating the point.

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

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

A single front-loaded sentence with no redundant words. The core action and intended timing are transmitted immediately.

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

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

For a tool with three optional parameters and no schema descriptions, the description omits how transaction scope is determined and what the default plugin_name implies. The presence of an output schema covers return values, but the agent still lacks enough context to reliably pass the correct plugin and label settings.

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 explain the three parameters. It only hints at 'named', which loosely maps to label; game_dir and plugin_name, including the surprising default 'AI_Test_DoNotUse.esp', are not addressed at all.

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 (create), object (named rollback point), and timing (before direct ESP/ESM file edits). This clearly separates it from sibling transaction tools like geck_transaction_list, geck_transaction_rollback, and geck_transaction_verify.

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 states when to call the tool: before direct file edits, which is the core use case. It does not explicitly contrast with alternatives or state when not to use it, so it stops just short of full 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?

The verb 'list' and the ordering 'newest first' convey a read-only, sorted listing, which is useful behavioral signal in the absence of annotations. However, 'recent' is unexplained, and no detail is provided about filesystem access, filtering behavior, or interaction with the current transaction lifecycle.

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

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

The description is a single compact sentence with no redundancy, and the core action, resource, and ordering are front-loaded. It is concise, though it sacrifices useful context by being so terse.

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?

Even though an output schema exists and all parameters are optional, the missing parameter semantics and lack of usage context make the description incomplete for non-default invocations. An agent cannot determine when to set plugin_name or game_dir, or how 'recent' is bounded.

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 tool description mentions none of the three parameters. An agent cannot tell from the description how limit, game_dir, or plugin_name affect the result; only bare property titles and defaults are available.

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 ('List') plus a specific resource ('recent MCP backup/transaction files') and an ordering constraint ('newest first'). It is reasonably distinct from sibling tools like listing plugins, though the phrase 'backup/transaction files' is slightly ambiguous.

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

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

No guidance is given on when to use this tool versus related siblings such as geck_transaction_verify, geck_transaction_rollback, geck_backup_plugin, or geck_list_plugins. The description only says what the tool does, not when it should be selected.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Restore' and does not disclose that the operation may overwrite an existing plugin, whether a pre-rollback backup is created, or what side effects occur during the restore.

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 with no filler and uses precise terms upfront. It is concise and readable, though it is brief enough that important operational details are pushed entirely into the schema.

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 mutating rollback tool with four parameters and no annotations, the description is underspecified. It does not clarify how plugin_name and game_dir scope the restore, how transaction_id_or_path and backup paths relate, or what conditions must be met for the operation to succeed. The output schema exists, so return format is not required, but invocation behavior is still incomplete.

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

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

Schema description coverage is 0%, so the description must compensate. It only adds meaning to transaction_id_or_path by mentioning 'or backup path inside the MCP backup directory'. It does not explain game_dir, plugin_name, or create_pre_rollback_backup, although their titles and defaults provide partial hints.

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 ('Restore'), the object ('a plugin'), and the source ('transaction id or backup path inside the MCP backup directory'). This meaningfully distinguishes it from related tools like geck_transaction_begin, geck_transaction_list, and geck_backup_plugin, even though it does not explicitly name sibling tools.

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

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

The usage is implied: restore a plugin from a transaction id or backup path, which suggests a rollback/undo scenario. However, there is no explicit guidance about when to prefer this tool over sibling alternatives, nor any mention of 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 disclosure burden. The verb 'Verify' implies a non-destructive inspection, and the listed targets clarify what is checked, but the description does not explicitly state that no changes are made, whether it is safe to run anytime, or what happens if verification fails.

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 repetition. It is appropriately concise for the amount of information it conveys, though the dense list of targets could benefit from a little more structure.

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 no annotations, no parameter documentation, and a broad family of overlapping sibling tools, the description is too thin to be fully actionable. The output schema covers return values, but the description does not explain prerequisites, expected usage flow, or how this verification differs from nearby state-inspection tools.

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

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

Schema description coverage is 0%, so the description must compensate by explaining how backend, game_dir, and plugin_name relate to the verification targets. It does not mention any parameter or how plugin_name selects the plugin to verify, leaving the agent without additional semantic guidance beyond the raw schema names and defaults.

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

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

The description names a clear action, 'Verify', and enumerates the resources involved: on-disk plugin state, active GECK plugin, placed records, and recent rollback points. It is understandable on its own, though it does not explicitly distinguish itself from overlapping siblings like geck_plugin_status, geck_active_plugin, or geck_transaction_list.

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

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

The description provides no guidance on when to use this tool versus related siblings, and it does not mention any exclusions or alternative tool choices. The transaction-related wording implies it may be used after transaction operations, but that connection is left entirely 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?

No annotations are provided, so the description must carry the behavioral burden. It does reveal that the tool validates plugin names and rewrites the load order, which is useful. But it does not disclose whether a backup is automatically created, how destructive the rewrite is, what happens with unlisted plugins, or any failure/rollback behavior.

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

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

The description is a single efficient sentence with no filler. The action and resource are front-loaded, and every word earns its place.

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

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

The output schema may cover return values, but this is a mutation tool with three parameters, no annotations, and no parameter documentation in the description. The 'backup' and 'game_dir' parameters especially need clarification for an agent to invoke the tool correctly, and prerequisite/rollback context 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?

Schema description coverage is 0%, so the description must compensate. The phrase 'plugin names' loosely maps to the 'plugins' parameter, but the 'backup' and 'game_dir' parameters are entirely unexplained. No format, ordering, or filename conventions are given for the plugin list.

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

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

The description names a specific verb ('Rewrite'), a specific resource ('Fallout 3 plugins.txt load order'), and an additional behavior ('after validating plugin names'). This clearly distinguishes it from sibling read/backup/list tools and makes the tool's function immediately obvious.

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

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

The phrase 'after validating plugin names' implies a prerequisite and gives some contextual guidance. However, it does not explicitly state when to use this tool versus alternatives like geck_read_load_order or geck_backup_plugin, nor does it mention exclusions or preconditions for safe use.

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