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, and it discloses almost nothing: it does not say whether the game must be running, whether this mutates saved state, whether it blocks/waits, or what happens when no dialogue is active. Only the bare claim that it acts on the current dialogue is offered.

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 one-sentence description is maximally concise and contains no filler, which is appropriate. But the brevity comes at the cost of under-specification rather than tightness, so it sits at minimum-viable rather than being a model of economical writing.

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

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

An output schema exists, so return values need not be explained, but for a state-mutating dialogue tool with one undocumented required parameter and no annotations, key context is missing: prerequisites (launched game, active dialogue), side effects, and failure modes. The definition is too thin to call it safely.

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

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

The single parameter project_path has 0% schema description coverage and the description says nothing about it — no path format, whether it is relative or absolute, or whether it must point at an already-launched project. The description therefore fails to compensate for the coverage gap.

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

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

States a verb (advance) and a resource (current dialogue), so the basic action is identifiable. However, 'advance' is ambiguous for a Ren'Py-style toolset — it could mean step one line, skip, or move to the next dialogue node — and no sibling (e.g. renforge_select_choice, renforge_jump) is named to disambiguate.

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 statement of when to use this versus alternatives such as renforge_select_choice for branches, renforge_list_choices for enumerating options, or renforge_jump for moving elsewhere. The 'current dialogue' phrasing weakly implies a dialogue must be active, but no explicit condition or exclusion is given.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the detection scope (orphaned AND missing, restricted to image/audio assets), which implies a read-only diagnostic pass. However, it never states that it is non-mutating, what counts as "orphaned," or any performance/auth constraints for scanning a whole project.

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. It is efficient, though its brevity edges toward under-specification rather than true completeness.

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

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

An output schema exists so return values need not be spelled out, but for a project-wide asset scan with no annotations and an entirely undocumented required parameter, the definition leaves the agent without scoping details, usage context, or behavioral guarantees.

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 single parameter project_path is undocumented in both the schema and the description. The description never mentions the path argument, what format it expects, or whether it points to a file or directory, so it fails to compensate for the coverage gap.

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

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

The description gives a specific verb ("Find") and a well-defined resource ("orphaned and missing image/audio assets in the project"), which is far more informative than the title "Renforge Assets". It does not, however, distinguish itself from adjacent scanning siblings such as renforge_scan_project or renforge_inspect_project.

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

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

There is no indication of when to reach for this tool versus renforge_scan_project, renforge_inspect_project, or renforge_find_references. No prerequisites, no exclusions, no alternative routing is provided.

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

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

No annotations are provided, so the description carries full behavioral burden. It implies a long-running, automatic playthrough but says nothing about runtime expectations, what happens to the game state afterward, whether it requires an already-launched game, or how failures are surfaced. 'Crashes' is mentioned but not defined.

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 the action front-loaded. It is appropriately short, though the terse phrasing sacrifices clarity for 'label coverage' and 'crashes'.

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

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

An output schema exists, so return-value explanation is not strictly needed. But for a complex multi-branch autopilot with 0% parameter coverage and no annotations, the description leaves important gaps around run limits, preconditions, and runtime behavior.

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 no parameters at all. max_runs (default 16) and max_steps (default 60) are the core knobs for an autopilot run and remain undocumented in both schema text and description, leaving the agent to guess their semantics.

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

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

States a specific action ('auto-play the game across all branches') and deliverables ('report label coverage and crashes'), which distinguishes it from low-level siblings like renforge_advance or renforge_run_scenario. However, 'label coverage' is jargon that isn't further defined, leaving some ambiguity about the exact output.

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

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

No guidance on when to use this batched autopilot versus alternatives like renforge_run_scenario, renforge_launch, or renforge_new_game. The description names no prerequisites, no comparison to siblings, and no conditions for choosing it.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose the write target ('controlled capture directory'), which is genuinely useful, but it says nothing about overwrite behavior for the default 'capture' name, permissions, or what source is captured — significant gaps for a persist/write operation.

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

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

A single front-loaded sentence with no filler, which is structurally sound, but its brevity is under-specification rather than discipline given the tool's 13-parameter surface. Nothing beyond the destination directory is conveyed.

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

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

An output schema exists, so return values need not be described, but for a 13-parameter snapshot tool with zero schema coverage and no annotations the description is far too thin. The capture source, cropping semantics, and overlay flags all go 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 mentions no parameters at all, leaving all 13 parameters (crop_x/y/width/height, crosshair_x/y, grid, scale, rulers, name, width/height) entirely undocumented. With this many non-obvious numeric and boolean controls, the description should compensate but does not.

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

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

The description gives a specific verb ('persist') and resource ('screenshot') plus a scope qualifier ('under the project's controlled capture directory'), so the operation and its destination are unambiguous. It does not, however, distinguish this from the sibling tool 'renforge_screenshot', which an agent must choose between.

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 rather than the similarly named 'renforge_screenshot', nor any stated prerequisites (e.g. a running game or an active window to capture). The agent must infer the selection criteria entirely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden for a mutating input-simulation tool. It hints at 'frame/state safety guards' but never explains what they do, what happens on a guard mismatch, whether the click is retried or fails silently, or whether it requires an active session. That is a major gap for a tool that mutates external state.

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

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

A single tight sentence with the action front-loaded and no filler. It is appropriately sized, though brevity here comes at the cost of the disclosure the tool needs.

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

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

An output schema exists, so return values need not be described. But for a 6-parameter, annotation-free, mutating input tool with 0% schema coverage, the description should explain coordinate space, guard semantics, and failure behavior; it does 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?

Schema description coverage is 0% across 6 parameters. The description only loosely gestures at coordinates and frame/state guards, leaving x, y, project_path, and especially coordinate_space ('logical' default) and expected_state's shape undocumented anywhere. Meaningful semantics are missing.

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

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

States a specific verb ('Click') and resource ('screen coordinates'), which is enough to separate it from renforge_click_element (element-based clicking). However, it does not explicitly name that sibling or contrast the two approaches, so the differentiation is implied rather than stated.

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

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

No guidance on when to prefer raw-coordinate clicking over renforge_click_element, renforge_click_at's nearest alternative, nor any prerequisites (e.g. required running game state, valid project_path). The agent must infer usage entirely.

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

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

With no annotations, the description must carry behavioral weight, and it does add real value: stale-frame guarding, the received_by return on hit-point contention, and correlated business-event waiting. However, it omits important failure modes such as what happens when no matching control exists or how visibility is determined, so disclosure is partial.

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

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

Front-loaded with the core purpose, followed by two compact sentences on return behavior and the effect-waiting option. No wasted words, though the phrasing is slightly dense.

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

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

An output schema exists, so return values needn't be detailed, and the description wisely avoids that. But for a 9-parameter mutation-style tool with zero annotation coverage and 0% schema coverage, key behaviors and parameter meanings remain missing, so completeness is only adequate.

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

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

Schema description coverage is 0% across 9 parameters, so the description must compensate, yet it only touches text/id, wait_for_effect, and the frame guard. screen, exact, interaction_id, effect_timeout, and project_path are left entirely unexplained, leaving most parameter meaning 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 states a specific verb and resource ('Click a visible control by text/id') and disambiguates the target strategy from coordinate-based siblings, making the intent clear. It does not explicitly name alternatives like click_at or hover_element, so it stops short of a full 5.

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

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

It gives a conditional hint for wait_for_effect but never states when to choose this tool over renforge_click_at, renforge_hover_element, or renforge_select_choice, nor any prerequisites for use. There is no explicit when-to-use or when-not-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden. It doesn't disclose whether this is a read-only operation, whether it has side effects, what happens if no active project exists, or how the three sources are prioritized. Only has an output schema, which helps, but behavioral traits like resolution precedence remain undisclosed.

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, short sentence — appropriately sized and front-loaded with the verb 'Discover'. The parenthetical is slightly cryptic but doesn't bloat the description.

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

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

The tool is simple (no params, has an output schema), so less description is needed. But the ambiguity about what 'dashboard, serve default, or cwd' means and the lack of usage guidance relative to sibling project tools leaves gaps for an agent trying to decide between this and renforge_inspect_project/renforge_scan_project.

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

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

There are zero parameters, so per calibration the baseline is 4. The description doesn't need to explain inputs and correctly adds no parameter detail.

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

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

The description states a verb and resource (discover the active Ren'Py project), which is reasonably clear. However, the parenthetical 'dashboard, serve default, or cwd' is ambiguous — it's unclear whether these are discovery sources/methods or outputs. Compared to siblings like renforge_inspect_project or renforge_scan_project, the specific purpose of this tool (resolving which project context is active) isn't fully differentiated.

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

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

There is no guidance on when to use this tool versus the many sibling project-inspection tools (renforge_inspect_project, renforge_scan_project). No mention of prerequisites or when-not conditions. Usage is only implied by the phrase 'active project', leaving the agent to guess.

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

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

With no annotations, the description carries the full burden and discloses that actions emit correlated business events and that wait_for_effect blocks until the event appears, which is useful. It does not disclose side effects, permissions, reversibility, or timeout behavior for destructive actions like quit or rollback, leaving significant gaps.

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

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

The description is front-loaded with the action list and then adds two tightly focused sentences about event emission and wait_for_effect. Every sentence adds useful information with no filler.

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

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

Given five parameters, 0% schema coverage, and no annotations, the description should do more to explain required project_path and optional effect_timeout/interaction_id. It covers the most important action parameter and wait_for_effect, and output schema covers return values, but the definition remains incomplete for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It enumerates the action parameter's twelve allowed values and explains wait_for_effect, but leaves project_path, effect_timeout, and interaction_id entirely undocumented, so it only partially fills the gap.

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

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

The description states a specific verb ('Run') and resource ('runtime action'), then enumerates the twelve valid actions, making the tool's scope immediately clear. However, it does not differentiate this generic control tool from overlapping siblings like renforge_advance or renforge_stop, so the agent must infer when this tool is preferred.

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 when-to-use or when-not-to-use guidance relative to the many sibling tools. The only usage hint is 'Set wait_for_effect=true to block until the matching event appears,' which is parameter-level rather than tool-selection guidance.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one important behavioral fact — that an empty after_path diffs against the current live frame — but says nothing about the threshold parameter's effect on sensitivity, tolerance to anti-aliasing, or any cost/side-effect profile of capturing a live frame.

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?

Three tight sentences: the operation and its return value are front-loaded, followed by parameter notes and use cases. No filler, and each sentence adds information an agent needs.

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

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

Because an output schema exists, the description needn't detail return values, and it correctly just names the bounding box. However, for a four-parameter tool with zero schema descriptions and no annotations, the undocumented threshold and project_path leave meaningful gaps for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate for all four parameters. It explains before_path ("a saved PNG") and after_path (including the empty-string semantics), but leaves project_path and especially the default-0 threshold completely unexplained.

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

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

The description states a specific verb ("Diff") on a specific resource ("two frames") and names the output ("the bounding box of what changed"), which cleanly separates it from sibling screenshot/capture tools that produce images rather than diffs.

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 two concrete use cases ("measure how far an element moved" and "confirm a tweak left everything else untouched"), which clearly situates the tool. It does not, however, name an alternative or state when not to use it (e.g., versus renforge_measure or renforge_find_image_on_screen).

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

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

No annotations are provided, so the description carries the full behavioral burden. It indicates a build/mutation operation and lists package targets, but omits whether builds overwrite existing output, how destination is used, required permissions, and other side effects.

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

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

A single front-loaded sentence with no filler, and the action is stated immediately. It is structurally clean, though its brevity is the source of the completeness gaps rather than a flaw in conciseness itself.

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

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

With no annotations, 0% schema description coverage, and a required project_path, the description is too thin for correct invocation. The output schema covers return values, but essential context about required inputs, destination behavior, and execution side effects is absent.

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 only explains 'package' via examples such as 'pc', 'mac', and 'linux'. The required 'project_path' and the 'destination' parameter remain undocumented, leaving key parameter semantics missing.

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

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

States a specific verb ('Build') and resource ('desktop distributions'), with examples for package values. The 'desktop' qualifier implicitly separates it from the sibling renforge_web_build, though no alternative is named. Clear enough for selection.

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/when-not guidance is given, and no build-related sibling is named as an alternative. The package examples suggest valid targets but do not explain when this tool should be chosen over related tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not say whether the operation is read-only, what 'stable' means, what the output looks like (beyond implying a translation result), or any constraints on input frames.

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

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

The single sentence is front-loaded and contains no filler. However, given the tool's complexity, it may be too terse to be optimally structured for an agent needing to understand configuration options.

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, an output schema, and no annotations or schema descriptions, the description is significantly incomplete. It omits usage context, parameter explanations, and behavioral traits, leaving the agent with little beyond the name and required inputs.

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

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

All 8 parameters lack schema descriptions (0% coverage). The description references 'two saved frames' which loosely maps to the required before_path and after_path, but it provides no meaning for the six optional parameters (region_x, region_y, max_shift, threshold, region_width, region_height).

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 ('Estimate') and resource ('visual translation between two saved frames'), making the core action understandable. It does not differentiate from sibling tools like diff_screenshots or mention any scope boundaries, so it stops short of a 5.

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

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

There is no guidance on when to use this tool, when not to, or which alternatives exist. The description only states what it does, leaving the agent to infer appropriate usage from the name and siblings.

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

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

No annotations are provided, so the description carries full disclosure burden for what is effectively arbitrary code execution. It mentions the store namespace, but says nothing about side effects, mutability, safety/security implications, or what happens on error — all critical for an eval 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?

One clean, front-loaded sentence with no filler. It is appropriately sized, though the terseness is bought at the cost of the missing behavioral and parameter detail.

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

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

An output schema exists so return values need no explanation, but for a powerful code-eval tool with two required, undocumented parameters and no annotations, the definition omits side-effect, safety, and project_path context an agent needs to invoke it correctly.

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

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

Schema description coverage is 0%, so the schema adds no meaning and the description must compensate. It clarifies that 'expr' is a Python expression, but never explains 'project_path' at all, leaving half of the required parameters undocumented.

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

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

States a specific verb (Evaluate), resource (a Python expression), and scope (the running game's store namespace), so the agent knows this is arbitrary-expression evaluation rather than variable get/set. It does not distinguish itself from nearby siblings like renforge_get_var/renforge_set_var or renforge_game_state.

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

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

The description only says what the tool does, with no guidance on when to reach for it versus alternatives such as renforge_get_var, renforge_set_var, or renforge_game_state. No prerequisites or when-not-to-use conditions are given.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether export writes a file to disk or returns text, where output lands, whether it is read-only or has side effects, or what happens with a missing/invalid project path.

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 short sentence with the action and resource front-loaded and no wasted words. The brevity is efficient, though it borders on under-specification given the surrounding gaps.

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

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

An output schema exists, so return values need not be described, but with no annotations and 0% parameter coverage the definition is missing the essentials: what the language filter does and whether/how output is persisted. For a two-parameter export tool this is too thin.

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 and it does not: neither 'project_path' nor 'language' is mentioned. The 'language' parameter in particular (a filter over which dialogue is exported, defaulting to "None") is left entirely unexplained.

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

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

States a specific verb ('Export'), resource ('the game's dialogue'), and output form ('plain text'), which is enough for an agent to know it produces a text dump rather than running translations. It does not, however, distinguish itself from nearby siblings such as renforge_generate_translations or renforge_estimate_translation.

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

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

The description gives no when-to-use context, no prerequisites, and names no alternative tool. An agent must infer from the name alone whether this is the right call versus the translation-oriented siblings.

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

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

With no annotations, the description carries the full behavioral burden, yet it discloses almost nothing beyond the verb. It does not explain what 'current frame' means, how matching behaves with the threshold, whether multiple matches are returned, the coordinate system of the bounds, or what happens when nothing 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?

One front-loaded sentence with no filler or repetition. It is efficient, though the brevity is a symptom of under-specification rather than genuine economy.

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

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

Image matching with 8 parameters and zero annotations is a nontrivial operation, and the description provides no scoping, error, or parameter context. The presence of an output schema excuses it from explaining return values, but the input-side gaps remain substantial.

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

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

Schema coverage is 0% across 8 parameters, so the description must compensate and does not. Only 'template image' loosely maps to template_path; threshold, max_matches, region_x/y/width/height, and project_path are entirely unexplained in both schema and description.

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

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

States a specific verb (find) and resource (a template image in the current frame) plus the return (its bounds), so an agent knows exactly what the tool does. It does not contrast this with siblings that also deal with images/screens (inspect_image, diff_screenshots, hit_test), so differentiation is left to inference.

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

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

The description gives no indication of when to reach for this tool versus alternatives like inspect_image, diff_screenshots, or hit_test, and states no prerequisites (e.g., that a frame must first be captured). A single-sentence description with no usage cues leaves the agent to guess.

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

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

With no annotations at all, the description carries the full behavioral burden and discloses almost nothing: it does not state that the operation is read-only, that results are paginated via limit/offset, or what happens when no match is found. 'Find' weakly implies a safe read, but no concrete behavioral trait is disclosed.

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. It is efficient, though its brevity is partly under-specification rather than disciplined concision.

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

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

An output schema exists, so return values need not be described, but the tool has five undocumented parameters, no annotations, and a scoping parameter (file_glob) that could dramatically change results. For a search tool with this surface area, the description is materially 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?

Five parameters with 0% schema description coverage, and the description explains none of them. limit, offset, file_glob, and project_path are entirely undocumented, and even 'symbol' is only indirectly implied by the phrase 'definitions/usages'. The description fails to compensate for the coverage gap.

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

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

States a specific verb (find) and resource (Ren'Py definitions/usages), with the qualifier 'exact' implying precision-oriented search and 'text interpolations' narrowing the search scope. It does not explicitly distinguish itself from lookup-oriented siblings like renforge_search_docs or renforge_inspect_project, so it stops short of a 5.

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

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

No when-to-use, when-not-to-use, or alternative-tool guidance is given. The word 'exact' hints at contrast with a fuzzy search, but the agent is left to infer when this tool beats renforge_search_docs or renforge_inspect_project.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Return' implies a read operation but it never states that explicitly, nor describes permissions, snapshot semantics, or side effects; only the optional-include behavior is disclosed.

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

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

A single front-loaded sentence with no wasted words. The 'compact' wording is slightly confusing given the sibling of the same name, but structurally it is tight.

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 return values, so the description needn't explain them. But with 0% schema coverage, no annotations, and an undefined 'live state', the definition is thin for a tool with a non-obvious include parameter.

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

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

Schema coverage is 0% for both parameters. The description hints at what 'include' can carry ('compact metrics or audio') but gives no valid values or syntax for the string-array, and says nothing about the required project_path.

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

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

States a specific verb and resource ('Return complete live state'), and 'complete' implicitly contrasts with the sibling renforge_game_state_compact. However, it never names that sibling or clarifies what 'live state' comprises, so the differentiation from the compact variant is only hinted at.

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 and no alternatives named, despite an obvious sibling (renforge_game_state_compact) that an agent must choose between. The phrase 'optionally include compact metrics' muddies rather than clarifies that choice.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose the key default (state_profile='interaction') and the safety property that the full store is not returned by default, which is useful. However it omits any mention of permissions, what happens on an invalid project_path, or boundedness behavior beyond the default profile.

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

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

Two tight sentences with no filler; the default behavior is front-loaded in the second sentence. Nothing wasteful, though it is brief enough that it sacrifices detail for brevity.

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

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

An output schema exists, so return-shape explanation is correctly omitted. But a 7-parameter tool with 0% schema coverage and no annotations is only partially covered by the description, leaving several bounding and selection parameters undocumented.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate. It only explains state_profile (with default and 'full' option) and touches on variable selection; max_depth, max_items, max_output_bytes, variable_prefix, and project_path get no semantic coverage anywhere.

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

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

The description states a specific verb+resource ('Return bounded live state') and immediately scopes it against the fuller alternative by noting the full store is never returned unless requested. It implicitly contrasts with the sibling renforge_game_state, though it never names it explicitly.

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

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

Usage is implied: use this tool when you want a bounded view rather than the full store, and set state_profile='full' when you need everything. There is no explicit when-to-use/when-not statement and no named alternative tool, so the agent must infer the routing against renforge_game_state.

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 behavioral burden. It discloses that it writes to 'game/tl/<language>/', which is useful, but does not state whether it overwrites existing files, merges changes, requires specific permissions, or what happens on failure. For a write operation, this leaves key behaviors unspecified.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately sized for the core purpose, though it could benefit from a bit more detail given the low schema coverage.

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 complexity (a write operation with no annotations, 0% schema coverage, and two required parameters), the description is not complete enough. It omits when to use the tool versus siblings, details about both parameters, and behavioral traits like overwrite behavior. The presence of an output schema means return values need not be explained, but other gaps remain.

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 neither parameter is documented in the schema. The description only implies the 'language' parameter is for the target language ('for a language') and says nothing about 'project_path' or the expected format of the language identifier (e.g., language code). It adds minimal meaning beyond the 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 uses a specific verb ('Generate/update') and resource ('translation files') with scope ('for a language') and even mentions the output path. It distinguishes itself from siblings that only estimate or show stats, though it does not name those alternatives explicitly.

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

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

There is no explicit guidance on when to use this tool versus siblings like renforge_estimate_translation or renforge_translation_stats. The implied usage is to create or update translation files, but no conditions, prerequisites, or alternatives 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 provided, so the description must carry the full behavioral burden. It discloses that output is in logical coordinates and that the image tag must be shown, but says nothing about permissions, side effects, error behavior, or whether coordinates are viewport-relative.

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

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

A single front-loaded sentence with no wasted words. It states the action, target, precondition, and coordinate system efficiently.

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

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

An output schema exists, so return values need not be described. However, for a tool with three parameters and no schema descriptions, the description omits parameter meaning, usage alternatives, and behavioral context, leaving significant gaps.

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

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

Schema description coverage is 0%, so the description must explain all three parameters, but it only loosely implies the 'tag' parameter. It gives no meaning for project_path or layer, nor does it clarify tag format or layer usage.

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

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

States a specific verb and resource: 'Report where a shown image tag was rendered, in logical coordinates.' It distinguishes itself from sibling bounds tools like renforge_get_ui_element_bounds by scoping to image tags and logical coordinates, though it does not explicitly name alternatives.

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

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

The phrase 'shown image tag was rendered' implies the tag must currently be displayed, giving some contextual usage guidance. However, it does not state when to use this over renforge_get_ui_element_bounds, renforge_find_image_on_screen, or other bounds-related 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?

No annotations are provided, so the description carries the full burden. It discloses the output format ('plain text'), which is a useful trait, but says nothing about failure behavior for an unknown topic, whether the topic is case-sensitive, or any constraints. Minimal behavioral disclosure for a no-annotation tool.

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

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

A single well-formed sentence with the action front-loaded and the example inline. No wasted words.

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

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

An output schema exists, so return values need not be explained. But for a doc-fetch tool sitting beside search_docs and list_docs, the description lacks the differentiation and topic-domain detail an agent needs to select and call it 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?

One parameter at 0% schema coverage, so the description must compensate. It supplies an example value (topic='cli'), which is genuinely helpful, but does not enumerate valid topics or explain the topic identifier scheme beyond that single sample.

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

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

States a specific verb+resource: reading a Ren'Py documentation page, and adds the return format ('as plain text'). However, it does not distinguish itself from sibling doc tools like renforge_search_docs or renforge_list_docs, so an agent cannot tell them apart from the description alone.

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

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

No guidance on when to use this versus renforge_search_docs or renforge_list_docs, which are obvious alternatives in the same doc-retrieval family. The reader must infer that this is for fetching one known topic while others search/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?

No annotations are provided, so the description carries the full burden. It hints that diagnostics are 'bounded' (implying a capped/truncated payload) and 'recent' (implying a time window), but says nothing about permissions, whether output is truncated, side effects, or why diagnostics may be unavailable.

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, which is appropriate for a two-parameter diagnostic tool. Its brevity is efficient, though it shades into under-specification rather than lean precision.

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

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

An output schema exists, so return-value shape need not be described, and the tool is a simple two-parameter read. However, with zero annotation and zero schema-description coverage, the missing 'since' semantics and the unexplained 'or' branch between two result types leave a gap for an agent deciding how to invoke it.

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

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

Schema description coverage is 0%, so the description must compensate and does not. 'Recent' loosely gestures at the 'since' parameter but gives no units, epoch format, or semantics, and 'project_path' is never explained or tied to the project being diagnosed.

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

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

States a specific verb ('Return') and concrete resources ('bridge exceptions', 'crash-file diagnostics'), which no sibling tool covers, so it is distinguishable from the rest of the renforge_* family. It loses a point for unexplained jargon ('bridge exceptions', 'bounded crash-file diagnostics') that leaves the exact artifact type 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?

There is no guidance on when to reach for this tool versus alternatives such as renforge_parse_lint or renforge_poll_events, nor any prerequisite or condition for use. The reader must infer the trigger scenario entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only report but does not state permissions, side effects, rate limits, or element selection behavior, leaving key traits undisclosed.

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

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

The single sentence is front-loaded and free of obvious filler. However, it is undersized for a tool with six parameters and no annotations, so it is concise only by omitting necessary detail.

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

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

An output schema exists, so return values need not be detailed. But with six input parameters and no annotations, the description omits required parameter guidance and element-selection context that an agent needs to call the tool correctly.

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

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

The input schema has 6 parameters with 0% description coverage, and the description mentions none of them. It does not explain project_path, element targeting fields, or expected_frame_id, so it fails to compensate for the schema gap.

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

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

The description states a specific verb ('Report') and resource ('focus bounds and rendered painted bounds for a UI element'), making the tool's core function clear. It does not explicitly distinguish this from sibling tools like renforge_get_displayable_bounds, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as renforge_get_displayable_bounds or renforge_hit_test. Usage context is only implied by the narrow description.

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

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

With no annotations, the description carries the full behavioral burden. It implies a non-mutating read and hints that the game must be running, but does not explicitly state that it is safe, what happens if the variable is missing, or any error or authorization 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 single sentence is front-loaded and wastes no words, which is structurally clean. However, it is arguably too sparse given the two undocumented parameters and lack of annotations.

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

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

An output schema exists, so return values need not be explained. But with 0% parameter description coverage and no annotations, the description is incomplete: it omits parameter semantics, usage context, and behavioral details needed to call the tool accurately.

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 implies the 'name' parameter is a variable name, but gives no format or examples, and completely ignores the 'project_path' parameter. Minimal value is added beyond the schema.

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

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

The description gives a specific verb ('Read') and resource ('variable') with a clear scope ('running game's store'), making the tool's core function immediately understandable. It distinguishes itself from siblings like renforge_set_var through the verb, though it doesn't explicitly name alternatives.

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

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

No guidance is given on when to use this tool versus alternatives such as renforge_game_state, renforge_eval, or renforge_set_var. The context is implied by the verb 'Read', but no explicit conditions, prerequisites, or exclusions 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 provided, so the description carries the burden. It discloses the read-only-ish nature ('inspect') and what the focus stack contains, but says nothing about side effects, permissions, or how coordinate_space affects results. Adequate but with clear gaps for an unannotated 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?

Two tight sentences with the core action front-loaded and no filler. Well-sized for the tool, though the second sentence is a slight restatement of the diagnostic payoff.

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

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

An output schema exists, so return values needn't be spelled out. However, with no annotations and 0% parameter description coverage, the description leaves coordinate_space and project_path semantics unaddressed, which is a meaningful gap for a 4-parameter tool.

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

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

Schema description coverage is 0%, so the description must compensate. It only hints at x/y via 'at a coordinate' and never explains project_path or the coordinate_space parameter (logical vs any alternative), leaving two of four parameters undocumented anywhere.

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

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

States a specific verb and resource ('Inspect the interactive focus stack at a coordinate') and clarifies the diagnostic intent ('detect transparent overlays that intercept clicks'). This differentiates it reasonably from click_at and get_ui_element_bounds, though it does not name any sibling explicitly.

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

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

Usage is only implied through the purpose statement about detecting overlays. There is no explicit when-to-use guidance, no conditions for choosing it over get_ui_element_bounds or list_ui_elements, and no 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 full behavioral burden. It discloses only that the target must be visible; it says nothing about how a failure is surfaced, whether hover state persists, what triggers or effects result, or any preconditions, which is a significant gap for a UI-interaction 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 front-loaded sentence with no wasted words. It is efficient, though arguably too terse for a 6-parameter interaction tool, which slightly undercuts its value.

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

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

Given 6 undocumented parameters, no annotations, and a UI-automation context, the description is far too thin. An output schema exists so return values need not be explained, but targeting, preconditions, and failure behavior remain unaddressed.

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

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

Schema description coverage is 0% across 6 parameters, so the description must compensate and largely does not. 'A visible control' weakly gestures at the element-targeting parameters (element_id, text, screen), but exact, expected_frame_id, and project_path get no clarification 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?

States a specific verb (move the pointer over) and resource (a visible control), and the phrase 'without clicking it' implicitly distinguishes it from the click siblings. It does not name an alternative explicitly, so it falls short of full 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 gives no when-to-use guidance, no prerequisites, and names no alternative tool. 'Without clicking it' hints at a contrast with click_element, but the agent is left to infer the trigger conditions and selection criteria on its own.

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

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

With no annotations, the description carries the full burden and mostly delivers: it discloses the fallback chain (dashboard selection -> serve default -> auto-detected Ren'Py project), that project_source reports which match occurred, and that a null active_project means only that auto-discovery failed. It does not cover failure modes or error reporting, but for a no-arg read-only info probe this is well above the norm.

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

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

Front-loads the imperative 'Call first' before any explanation, then spends its remaining sentences entirely on non-obvious semantics (fallback order, project_source, null meaning). No sentence is filler.

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

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

An output schema exists, so return-value documentation is not required, yet the description still interprets the two most ambiguous output concepts (active_project nullability and project_source). Combined with the routing advice, an agent has everything needed to call this correctly as a first step.

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

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

The tool takes zero parameters, so the baseline of 4 applies. The mention of project_path is about sibling tools rather than this tool's own inputs, but it usefully clarifies why a null result is not a dead end.

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

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

States a specific verb and resource ('report RenForge version and the active project') and opens with 'Call first', which cleanly separates it from the dozens of sibling tools. An agent can identify this as the entry-point/status tool without reading any schema.

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

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

Explicitly prescribes when to use it ('Call first'), and goes further by explaining what to do when the result is empty — ask the user for the game's path and continue, since every tool accepts project_path. That is genuine when/how-to-proceed guidance, not just 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 exist, so the description carries the full behavioral burden. It discloses the return artifact (PNG) and that cropping/zooming are optional, but says nothing about file-system access, path expectations, whether the PNG is written to disk or returned inline, or any size/format limits.

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 waste; the verb and return value come first. It is efficient, though the brevity contributes to the gaps in the other dimensions rather than serving completeness.

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

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

With no annotations, no output schema, and 6 undocumented parameters, the description is too thin for the tool's complexity. An agent cannot determine crop coordinate semantics or where the resulting PNG goes without trial and error.

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

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

Schema coverage is 0% across 6 parameters, so the description must compensate and largely does not. It gestures at crop and zoom, loosely mapping to scale/crop_x/crop_y/crop_width/crop_height, but gives no units (pixels vs normalized), no meaning for default 0 crop values, and no explanation of image_path handling.

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

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

States a specific verb and resource ('Open a local image') plus the return type ('optional cropped/zoomed PNG'). It implicitly separates itself from siblings like renforge_screenshot or renforge_find_image_on_screen by scoping to local files, but never explicitly names 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?

The only guidance is the trailing 'for inspection,' which gives no condition for choosing this over renforge_inspect_screen, renforge_screenshot, or renforge_diff_screenshots. No prerequisites, no when-not-to-use.

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

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

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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

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

With no annotations, the description carries the full burden. It implies a running game is required ('active screen') but doesn't state this as a precondition, nor whether the tool is read-only, what it does if no screen is active, or what 'JSON-safe' scoping entails.

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 tight sentence with the resource front-loaded; nothing is wasted. It is arguably under-specified rather than verbose, but structurally it is clean.

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

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

An output schema exists, so return values needn't be described, but with zero annotation coverage, 0% parameter documentation, and 49 sibling tools to disambiguate from, one terse sentence is not enough for an agent to invoke this correctly.

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

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

Schema description coverage is 0% and both parameters (project_path, name) are undocumented anywhere. The description mentions 'screen' and 'layer', which loosely hints that 'name' identifies a screen, but it never explains the parameters, their format, or valid 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?

States a verb (inspect) and a resource (an active screen's layer, scope, arguments), which is more than a tautology. However, it doesn't distinguish itself from siblings like renforge_inspect_image or renforge_inspect_project beyond the word 'screen', and 'JSON-safe scope' is jargon that doesn't clarify what is actually returned.

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

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

No guidance on when to use this tool versus the many other inspect/state tools (inspect_project, scene_tree, game_state, list_ui_elements). The word 'active' hints at a prerequisite but the when/when-not 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses that the operation restarts execution and may still be starting, requiring polling of launch status. However, it omits side effects, state implications, permissions, and version 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, front-loaded sentence with a semicolon separating the action from the polling guidance. It is concise and wastes no words, though it is arguably too terse for the tool's parameter complexity.

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

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

For a mutation-like tool with no annotations, 0% schema description coverage, and three parameters, the description is incomplete. It does not explain project_path requirements, version semantics, target syntax, or what restarting entails, even though an output schema exists.

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% for three parameters. The description only implies the meaning of 'target' via 'label or file:line'; it says nothing about 'project_path' or the 'version' parameter, leaving most parameter semantics 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 gives a specific verb and target: 'Restart at a label or file:line'. This distinguishes the action from generic restart or launch siblings, though it does not explicitly name which sibling to prefer.

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 only advises 'poll launch status when still starting', which is a follow-up condition rather than guidance on when to use this tool instead of alternatives like renforge_launch, renforge_advance, or renforge_launch_status. No when-not or alternative selection is provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says the tool lists languages; it does not state whether the operation is read-only, what permissions are required, or any other behavioral trait. This is a significant gap for a tool with zero annotation coverage.

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

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

The single sentence is front-loaded, efficient, and wastes no words. It is appropriately sized for a simple list tool, though it could benefit from slightly more context without becoming verbose.

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

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

While an output schema exists (so return values need not be explained), the description fails to document the required project_path parameter despite 0% schema description coverage. With no annotations either, the definition leaves the agent without enough information to invoke the tool correctly, making it incomplete for a tool with a mandatory input.

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 required parameter (project_path) with 0% description coverage, and the description does not mention or explain it at all. The phrase 'under game/tl/' provides no meaningful clarification of what project_path should be, so the description adds no semantic value beyond the bare schema.

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

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

States a specific verb (List) and resource (translation languages under game/tl/), making the tool's function clear. It does not, however, explicitly distinguish itself from sibling translation-related tools like renforge_translation_stats or renforge_export_dialogue, so it misses the top mark for sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. It only states what the tool does, leaving the agent to infer usage context entirely.

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

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

With no annotations, the description carries the full burden and does much of it: it discloses the 20-second wait ceiling, the status="starting" background-startup contract, and that timeout governs the startup deadline rather than the MCP call. It omits the 'reuse' semantics when a game is already running and the effect of cleanup_on_stop=true, leaving some mutation behavior undisclosed.

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

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

Front-loaded with purpose, then workflow, then behavioral caveats; every paragraph is scannable. The click/verify/stop workflow is arguably beyond this tool's own contract, adding mild length without harm.

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

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

An output schema exists so return values needn't be spelled out, and the description still clarifies the status field. However, for a 10-parameter mutation tool with zero schema coverage, three parameters and the reuse/cleanup behavior remain unexplained, leaving real gaps.

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

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

Schema coverage is 0% across 10 parameters, so the description must compensate. It explains editor, warp (Ren'Py file:line target), display/audio defaults, savedir='temporary' isolation, and timeout semantics, but leaves version, persistent, and cleanup_on_stop entirely undocumented.

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

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

States a specific verb and resource ('Launch or reuse a game') plus the default condition (Live Editor enabled). An agent can distinguish it from renforge_launch_status (polls state) and renforge_stop (tears down) without opening any schema.

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

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

Gives an explicit post-launch workflow: poll renforge_launch_status until ready, observe with a fresh renforge_screenshot/renforge_scene_tree before any click, then renforge_stop. It names sibling tools but never states when to prefer renforge_launch over renforge_new_game or when launching is inappropriate, so it stops short of full when/when-not guidance.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does reveal that the operation is asynchronous ('background launch') and lists the four possible states, which is useful, but says nothing about which launch is being tracked, whether polling is required, or any auth/rate-limit behavior.

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

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

A single front-loaded sentence with zero filler; it leads with the action (Return) and immediately enumerates the possible outcomes. Nothing needs trimming.

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 state values need not be re-explained, and there is only one self-evident parameter. However, the description omits the crucial linkage between this tool and renforge_launch (which launch is being queried, whether polling is expected), leaving a real gap for an agent orchestrating an async 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% and the description adds no information about project_path — not its format, whether it must match the path passed to renforge_launch, or whether an empty value targets the default project. The parameter is only self-explanatory by its name.

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

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

States a specific verb (Return) and resource (launch status for a background launch), and enumerates the concrete result states ('starting, ready, failed, or idle'). It implicitly separates itself from renforge_launch, though it never names the sibling or explicitly says it reports on a launch initiated elsewhere.

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 'for a background launch' implies this is a polling companion to renforge_launch, but the description never states when to call it, how often to poll, or what to do with each state. No alternatives or exclusions are offered; usage is only inferred.

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 never states that a game session must be running or that choices may be empty/absent, and gives no sense of ordering, stability, or whether the index is stable across frames.

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 repetition. It is arguably too terse given the omissions elsewhere, but it wastes nothing.

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

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

An output schema exists, so return values need not be explained, and the description correctly summarizes the payload as text + index. However, preconditions (running game, project context) and the relationship to renforge_select_choice are missing for what appears to be a stateful UI-inspection tool.

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

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

Schema description coverage is 0% and the single required parameter project_path is undocumented in both schema and description. With one undocumented parameter, the description should have said what project_path refers to and whether it must point at an existing project.

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

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

States a clear verb ('List') and a specific resource ('on-screen menu choices'), plus the return shape ('text + index'). It implicitly distinguishes itself from renforge_list_ui_elements by scoping to menu choices, but never names or contrasts with that sibling explicitly.

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

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

No when-to-use guidance and no mention of alternatives such as renforge_select_choice, which is the obvious companion tool for acting on the listed choices. The agent must infer that this is a prerequisite step before selecting a choice.

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

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

With no annotations, the description carries the full disclosure burden, but for a zero-parameter listing tool the burden is light. It implies a read-only enumeration of topics, yet says nothing about ordering, pagination, or whether the list is scoped to an installed project.

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

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

A single front-loaded sentence with zero filler. Nothing is wasted, though nothing extra is offered either.

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

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

An output schema exists, so return values need not be explained, and with zero parameters there is little to document. However, the description omits the one thing an agent still needs: how this differs from renforge_search_docs and renforge_get_doc in a 50-tool set.

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

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

The tool takes no parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool applies.

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

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

States a specific verb+resource: listing Ren'Py documentation topics. An agent can tell what it returns, but the description never distinguishes it from the closely related siblings renforge_search_docs and renforge_get_doc, so the boundary between listing, searching, and fetching is left to inference.

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

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

No when-to-use guidance and no alternatives named, despite two obvious alternatives in the sibling set (renforge_search_docs, renforge_get_doc). An agent must guess whether to call this before searching or fetching a specific topic.

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

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

With no annotations, the description carries the full burden, and it does disclose filtering behavior (only visible, focusable controls) and return content (bounds). However, 'frame guard' is unexplained jargon, and it never says whether this is a read-only operation or whether a running game/session is required.

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

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

A single front-loaded sentence with no wasted words, leading with the verb and resource. The terse phrasing slightly hurts comprehension because 'frame guard' is never defined.

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

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

An output schema exists so return values need not be explained, but four parameters with 0% schema coverage and no annotations leave the filtering semantics and prerequisites (e.g. whether the project must be running) undocumented. The description is too thin for a tool with this much structured-data silence.

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 schema documents nothing about text, screen, element_type, or project_path, and the description offers no compensating explanation of their meaning or format. The phrase 'visible focusable' only loosely hints at the element_type filter.

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

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

States a concrete verb ('List') and resource ('Ren'Py controls') with a scope qualifier ('visible focusable') and names what is returned ('bounds and frame guard'). This separates it from siblings like renforge_click_element or renforge_scene_tree, though it never names an 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?

There is no explicit when-to-use or when-not-to-use guidance and no mention of the sibling tools (renforge_scene_tree, renforge_get_ui_element_bounds, renforge_click_element) that overlap in purpose. Usage is only implied by 'visible focusable'.

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 burden and does so fairly well: it says the tool works 'without eyes' (no screenshot), returns actionable deltas in logical pixels, adds a `pass` verdict only when `tolerance` is supplied, and that `contrast` samples the live frame live rather than from cached data. It does not state side effects, permissions, or whether the operation is purely read-only, which is the remaining gap for an unannotated tool.

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

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

The purpose is front-loaded in the first clause, followed by parameter and return semantics in tight, backticked fragments. Every sentence carries distinct information — the action list, target resolution, return units, and the tolerance/contrast special cases — with no filler.

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

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

An output schema exists so return values need minimal prose, and the description still usefully names the delta/tolerance-verdict shape. It also answers the key integration question (where node ids come from). The residual gaps are the unexplained `project_path` and the absence of any guidance relative to overlapping siblings.

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 and largely does: `action` is enumerated (7 values), `targets`/`within` are defined as either a `renforge_scene_tree` node id resolved live or a literal bounds object `{x,y,width,height}`, and `tolerance` is explained as a pass/fail threshold. Only `project_path` goes unexplained, but its meaning is largely self-evident.

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

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

States a specific verb and resource ('measure pixel relationships between scene nodes') and enumerates the seven measurement modes, so its scope is clear. However it never differentiates itself from sibling tools — notably `renforge_distribute`, which appears to overlap with this tool's `distribute` action — so the agent gets no sibling-level disambiguation.

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 per-action explanations imply when each mode applies (e.g. `contrast` samples the live frame for a WCAG ratio), which gives implied usage. But there is no explicit when-to-use, when-not, or pointer to alternatives (`renforge_get_ui_element_bounds`, `renforge_position_element`, `renforge_distribute` are all plausibly related), leaving the routing decision 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 carries full burden. It does not say what starting a game does, whether it is destructive to an existing session, what permissions or preconditions are needed, or what happens on success or failure. The mention of polling suggests a two-step flow but is too vague to be actionable.

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

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

The description is short and front-loaded around the start label, but it mixes behavioral instructions ('poll launch status') with unclear terminology. It is not bloated, but its brevity comes at the cost of clarity.

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

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

Given an output schema exists, return values need not be explained, but the description omits parameter meaning, preconditions, and how this tool differs from renforge_launch/renforge_launch_status. For a game-starting tool with zero schema coverage, it is substantially 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 says nothing about either parameter (project_path, version). With two parameters completely undocumented and no description to compensate, an agent cannot know what project_path should point to or what version accepts.

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 'Start at the ``start`` label; poll launch status when still starting' hints at launching a game and interacting with a 'start' label, but the name renforge_new_game is not clarified beyond a snippet about labels and polling. It is unclear whether this tool starts a new game session or something else, and it overlaps confusingly with siblings like renforge_launch and renforge_launch_status.

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

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

There is no explicit when-to-use or when-not-to-use guidance; the phrase about polling launch status implies follow-up with renforge_launch_status but does not name it or give conditions. An agent would have to guess whether to call this, renforge_launch, or renforge_jump.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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

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

No annotations exist, so the description carries the full behavioral burden. It discloses only the event categories and the incremental cutoff; it says nothing about whether polling consumes or drops events, whether calls block, ordering guarantees, or cursor/sequence semantics — all critical for a polling 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 front-loaded sentence with the action, the payload, and the cursor constraint. No filler.

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

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

An output schema exists, so return-value explanation is rightly omitted. However, for a stateful polling cursor tool with zero annotation and zero schema-description coverage, the description leaves key invocation semantics (cursor units, consumption behavior) unspecified.

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 usefully explains that `since` is a lower bound on event recency, but leaves the type ambiguous (integer sequence counter vs. timestamp) and says nothing about `project_path`, the required parameter.

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

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

States a specific verb (return/poll) and resource (pushed events), and enumerates the payload kinds: dialogue, labels, exceptions. An agent can distinguish it from siblings like renforge_get_errors or renforge_game_state, though it doesn't name a sibling explicitly to sharpen the boundary.

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 statement of when to call this versus alternatives (e.g. renforge_get_errors, renforge_game_state). The `since` cursor implies an incremental-polling pattern, but the agent must infer that entirely; there are no exclusions or prerequisites.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the tag keeps its current attributes, that it returns new logical bounds, and the crucial int-vs-float coordinate rule. However, it never states the key precondition (a running game with the tag shown) or what happens on failure, so for a mutation-style runtime tool this is only partially 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?

Four short sentences, front-loaded with purpose before the mechanics and the int/float rule. Each sentence carries information; only the final 'write into the .rpy' sentence edges toward workflow advice rather than tool semantics.

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

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

An output schema exists, so return values needn't be spelled out, and the description does mention logical bounds anyway. Given 13 parameters and a runtime-mutation behavior, the missing preconditions (game must be launched, tag must be shown) and the undocumented anchor/offset/zoom parameters leave the definition thin.

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

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

Schema description coverage is 0% across 13 parameters, so the description must compensate. It explains the semantics of xpos/ypos (integer = pixels, float = fraction) and the 'at least one placement field' rule, which is the highest-value guidance. But xalign, yalign, xanchor, yanchor, xoffset, yoffset, zoom, rotate, and layer are entirely undocumented anywhere.

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 first sentence states a specific verb (reposition), resource (a shown image tag), and effect (returns its new logical bounds), and the word 'live' scopes it to runtime manipulation. This distinguishes it cleanly from read-only siblings like renforge_get_ui_element_bounds or renforge_get_displayable_bounds.

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 real usage context: 'Use this to converge on coordinates interactively, then write the final values into the .rpy script', plus the constraint 'Provide at least one placement field'. It does not name a specific alternative sibling or state when NOT to use it, so it falls short of a 5.

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

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

With no annotations, the description carries the full burden and does add real value: it discloses that failures auto-capture a screenshot and compact diagnostics, which explains the capture_on_failure behavior. It does not state that this is a state-mutating live run (click/advance/save/load/control) or what permissions/timeouts govern it, so disclosure is partial.

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

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

Front-loaded with the core purpose and failure behavior before the step-action enumeration. The 15-item action list is long but earns its place by telling the agent what the steps array can contain; overall structure is efficient.

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

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

An output schema exists so return values need not be described. However, with 7 params at 0% schema coverage and no annotations, gaps remain around what project_path and state_profile mean and what timeout measures, leaving the agent partially under-informed for a complex multi-step execution tool.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate and largely does not: timeout, project_path, state_profile, name, and stop_on_failure are never explained. It lists supported step actions, which is the only meaningful parameter-adjacent information, but that list maps to the steps array content rather than to the declared properties.

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

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

States a specific verb+resource ('Run a multi-step live scenario') and the key differentiator 'in one call', which distinguishes it from the many single-step siblings like renforge_click_at, renforge_advance, and renforge_wait_until. It does not explicitly name those siblings as alternatives, so it falls just short of the top tier.

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 'in one call' implies this is the batch alternative to issuing many individual step calls, and the step-action list hints at scope. But there is no explicit when-to-use/when-not guidance or named alternative, leaving the agent to infer the composite-vs-single distinction.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does hint at a behavioral trait (no screenshot payloads are included) but omits whether save operations overwrite existing slots, what happens if a slot is missing on load, or auth/permission needs. For a mutation-capable 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 sentence, front-loaded with the verb list and ending on the key scope caveat. It is appropriately sized for the amount of information given.

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

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

With 5 parameters at 0% schema coverage, no annotations, and no output schema details available to the description text, the definition is far too thin. The action parameter accepts arbitrary strings with no enum constraints, and the description makes no attempt to enumerate valid actions or parameter expectations.

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 mentions 'named save slots', which does not explain the five parameters (slot, action, regexp, extra_info, project_path) or their accepted formats, despite the schema providing no descriptions 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 states specific verbs (save, load, list) and a resource (named save slots), including a distinguishing scope note (without screenshot payloads). It is clearly distinguishable from siblings like renforge_screenshot or renforge_capture_screenshot. However, it does not name a specific alternative tool, so it stops short of the sibling-differentiating 5.

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

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

The three supported actions are implied, but there is no explicit guidance on which action to pick, when to use this over renforge_game_state or renforge_new_game, or any prerequisites for slot naming. Usage is only weakly implied.

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

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

No annotations are provided, so the description carries the full burden. It does disclose default behavior (summary-only), opt-in sections, and pagination, which is useful, but it omits safety/read-only status, permission requirements, and 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?

A single, front-loaded sentence with no filler. It is perhaps too terse for the tool's complexity, but the sentence itself is efficiently structured and every word 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 6-parameter tool with no parameter descriptions and no annotations, the description is far too thin. Even with an output schema handling return values, the absence of usage and parameter guidance leaves significant gaps for an agent.

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

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

Schema description coverage is 0% and there are 6 parameters, so the description must compensate but does not. It only indirectly alludes to 'sections' and pagination-related parameters while leaving project_path, symbol, and file_glob completely undocumented.

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

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

States a verb ('Scan') and resource ('scripts'), so the basic action is identifiable. However, it does not differentiate this tool from siblings like renforge_inspect_project or renforge_parse_lint, and 'scripts' is vague without mentioning the required project context.

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

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

No when-to-use guidance, no alternatives, and no exclusions are given. The default summary-only behavior is a trait, not an instruction for selecting this tool over siblings.

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

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

With no annotations, the description carries the full burden and does much of it: it names the returned fields, discloses that every reply carries an `omitted` completeness hint, lists the detail modes, and states the side effects of `save_as` (persists under `.renforge/scenes/`) and `diff_against`. It stops short of declaring read-only-ness or the cost/limits of the large payloads this can produce.

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

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

Front-loaded with the core purpose and sibling contrast, then dense but high-yield sentences on scoping and options. Slightly long, but every clause maps to a real parameter or output behavior, so little is wasted.

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 an output schema exists, return values needn't be spelled out, yet the description still enumerates key fields and the `omitted` hint. It covers most of a 13-parameter surface; the gap is the max_items/max_output_bytes/max_output_depth truncation controls, which matter for a tool whose output can be large.

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

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

Schema description coverage is 0% across 13 params, so the description must compensate, and it does for most: it defines the `detail` enum values, the `layers`/`types`/`screen`/`ids` scoping role, the `include` composited colour/style/overflow options, `format="wireframe"`, `save_as`, and `diff_against`. The remaining params (project_path, max_items, max_output_bytes, max_output_depth) are left undocumented in both schema and description.

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

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

States a specific verb+resource ('Perceive the whole scene as structured data') and immediately contrasts it with the sibling `renforge_list_ui_elements`, clarifying that this covers every layer displayable, focusable control and text block rather than focusables only. An agent can distinguish this from the other inspection tools without opening the schema.

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

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

The description explicitly routes the agent: use the sibling when only focusables matter, use this when the whole scene is needed, and it enumerates the scoping knobs (layers/types/screen/ids) and output shapes. It gives clear context but no explicit when-not or other alternatives (e.g., renforge_inspect_screen, renforge_hit_test).

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

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

With no annotations, the description carries the full burden. It does disclose real behavior — aspect-ratio preservation when only one of width/height is supplied, and the semantics of grid/rulers/crosshair overlays — but says nothing about the return format (image bytes? path?), whether the capture has side effects, or any permissions/state requirements.

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

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

Front-loads the core action in one sentence, then adds implementation detail on the measurement overlays. It is appropriately sized and every sentence contributes; no filler.

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

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

For a 12-parameter tool with 0% schema coverage and no output schema, the description leaves notable gaps: crop and scale semantics, the meaning of project_path, and what the tool returns. It adequately covers the distinctive overlay features but not the whole calling surface.

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

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

Schema coverage is 0% across 12 parameters, so the description must compensate. It meaningfully explains grid, rulers, crosshair_x/crosshair_y, and the width/height aspect-ratio rule, but crop_x/crop_y/crop_width/crop_height and scale are only implied by 'cropping'/'resizing', and project_path (the sole required param) is never described. Roughly half the surface is covered.

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

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

The description names a specific verb and resource ('Capture a game frame') and enumerates the optional transformations (resizing, cropping, zooming), so an agent knows exactly what the tool produces. It stops short of distinguishing itself from the closely-named sibling 'renforge_capture_screenshot', leaving overlap unresolved.

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

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

There is no explicit when-to-use guidance and no routing to alternatives, even though 'renforge_capture_screenshot', 'renforge_find_image_on_screen', and 'renforge_inspect_image' clearly overlap in scope. The measurement-guide sentence implies a use case for pixel-perfect placement, but it never frames this as a decision criterion versus 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state read-only safety, side effects, authentication needs, rate limits, or pagination behavior; only the naturally implied local/offline nature of searching. Return values are covered by the output schema, but safety and operational behavior remain largely undisclosed.

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 wasted words, front-loading the action and resource. Appropriately sized for a simple search 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 has an output schema covering return values, so the description need not explain results. However, it lacks routing guidance versus sibling doc tools and does not fully compensate for the 0% parameter description coverage, leaving gaps for an agent selecting and invoking it.

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

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

Schema description coverage is 0% for the single required parameter. The description says 'for a keyword', which loosely maps to the query parameter, but does not clarify format, whether multiple terms are allowed, or phrase versus single-keyword behavior.

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

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

States a specific verb ('Search') and resource ('Ren'Py's offline documentation'), with scope ('for a keyword'). Clear on its own, but does not distinguish from sibling tools like renforge_get_doc or renforge_list_docs.

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

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

No guidance on when to use this tool versus alternatives such as renforge_get_doc or renforge_list_docs, nor any stated prerequisites. The agent must infer that this is for discovering documentation rather than retrieving a specific known document.

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 state whether this requires the game to be in a specific state, whether the project_path must point to an active session, what happens on failure, or if the action is reversible. Only the selection mode is disclosed.

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, well-structured sentence that front-loads the primary action and clarifies the selection modes with a clear preference. No wasted words.

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

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

Although an output schema exists (so return values need not be explained), the description is incomplete for a tool with 3 parameters, 0% schema coverage, and no annotations. It omits any behavioral context such as required session state, error conditions, or how it interacts with sibling tools like renforge_list_choices.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that 'text' is the visible text of the choice and 'index' is an alternative selector, which adds some meaning. However, it doesn't clarify the default values (-1 for index means unset), nor does it explain what project_path refers to, leaving a key parameter completely undocumented.

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

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

The description states a specific verb ('Select') and resource ('a menu choice'), and clarifies the two selection modes (visible text preferred, or index). It distinguishes itself from siblings like renforge_list_choices and renforge_click_element, though the 'Renforge' context isn't 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 parenthetical '(preferred)' hints that text is preferable to index, which is implicit usage guidance. However, there is no explicit statement of when to use this tool versus renforge_list_choices or renforge_click_element, nor any prerequisites 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?

No annotations are provided, so the description carries the full burden. It usefully discloses that text posts character-by-character TEXTINPUT events to a focused Ren'Py Input, submit optionally presses Enter, key accepts readable key names, and scroll uses logical game coordinates. It does not cover failure modes, what happens when no Input is focused, side effects, permissions, or error behavior.

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

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

The description is front-loaded and mostly efficient, with detailed mode semantics packed into a short space. It has a minor redundancy: the first sentence and last sentence both state that exactly one input mode must be supplied.

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 5 parameters, 0% schema description coverage, no annotations, and an existing output schema, the description gives solid input-mode detail but remains incomplete. It leaves the required project_path unexplained and does not address behavioral preconditions or failure behavior.

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

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

Schema description coverage is 0%, so the description must compensate. It explains text, key, scroll, and submit semantics in useful detail, but omits the required project_path parameter entirely and does not fully compensate for the complete lack of schema descriptions.

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

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

States a specific verb and resource: sending exactly one input mode (text, key, or scroll). It is clear what the tool does, but it does not distinguish itself from siblings such as renforge_control, renforge_click_element, or renforge_advance, which also relate to game input/interaction.

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?

Explains the mode constraint that exactly one of text, key, or scroll must be supplied, and describes what each mode does. However, it provides no when-to-use guidance versus alternatives, no exclusions, and no routing to sibling tools for other input scenarios.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it omits whether the value persists across sessions, what type coercion applies, whether existing values are overwritten, and what happens if the game isn't running. For a mutation tool with zero annotation coverage this is a significant gap.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though the brevity edges into under-specification rather than optimal conciseness.

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

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

An output schema exists so return values need no explanation, but for a three-parameter mutation tool with 0% schema coverage and no annotations, the description leaves too much unstated: required parameters, side effects, and runtime prerequisites are all absent.

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 detail beyond the general notion of a variable name and value. It never mentions project_path, which is required, so it fails to compensate for the undocumented 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?

States a specific verb ('Set') and resource ('a variable in the running game's store namespace'), which cleanly distinguishes it from the sibling renforge_get_var. It doesn't explicitly name the sibling, but the read/write contrast makes the purpose unambiguous.

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