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

No annotations exist, so the description carries the full burden and does well: it discloses the mutation is scoped ('safe, targeted fixers'), explains each fixer's concrete effect, and explicitly flags 'missing_labels' as report-only rather than a mutating fixer. It stops short of stating file backup/reversibility or permission requirements for a tool that edits project files.

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 one-line purpose before the fixer catalog, and the bulleted fixer list earns its length because those names are otherwise undocumented in the schema. The trailing Returns block is redundant-free but slightly verbose against a short signature.

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 2-param mutating tool with no annotations and no output schema, the description covers purpose, both parameters, fixer semantics, and the return shape (ok/applied/skipped and before/after compile status). Only safety around editing files (backups, partial-failure behavior) is left unstated.

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, and it does: project_path is defined as the absolute project root and fixes as a list of fixer names with a None default meaning 'run all'. Critically, it enumerates the valid fixer names that the schema (which only types them as plain strings) does not constrain, which is the key semantic the caller needs.

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+outcome: detect and repair Ren'Py issues then re-compile to verify. The verb 'repair' differentiates it from siblings like tool_lint_project, tool_check_project, and tool_compile_project, which only diagnose or build.

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?

'Runs a set of safe, targeted fixers' and 'If None, runs all fixers' give implied usage context, and the instruction that it re-compiles afterward signals when it fits. However, it never explicitly contrasts itself with the sibling diagnostic tools (lint/check/list_fixers) or states when NOT to auto-fix, leaving the routing decision partly to inference.

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

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

With no annotations, the description carries the full burden and does reasonably well: it enumerates the failure modes detected and lists the return keys (ok, source_language, available_languages, buttons, issues). It does not explicitly state that the check is non-mutating or whether it requires a valid compiled project, but the read-only nature is strongly implied by 'Verify' and the diagnostic framing.

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

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

Purpose is front-loaded in the first sentence, followed by the diagnostic detail and the args/returns blocks. The parenthetical explaining Language(None) vs Language("english") is long but earns its place by clarifying the exact bug being detected; nothing is pure 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?

There is no output schema, so the description appropriately documents the return dict keys, and it covers the sole argument. For a focused static-check tool this is close to complete, though it omits any note on prerequisites (e.g., whether the project must be compiled) or the shape of the 'issues' entries.

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

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

Schema coverage is 0% and the schema only gives the parameter name and type, so the description's 'Absolute path to the Ren'Py project root directory' adds real meaning (root directory, absolute requirement) that the schema lacks. With a single parameter fully explained, this is solid.

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: verifying the language picker in screens.rpy against tl/ folders and config.language. It is concrete enough to distinguish from generic file tools, but it never names the closely related siblings tool_check_translation or tool_list_translations, which an agent could plausibly confuse it with.

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

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

It gives a clear usage scenario: catching the misconfiguration where the English button appears to do nothing, plus the dead/missing button cases. It supplies context for when the tool is relevant but offers no explicit when-not-to-use guidance or alternative routing.

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

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

With no annotations, the description carries the full burden and does reasonably well: it discloses the compile-fail short-circuit control flow and the side effect of force clearing the .rpyc cache before compiling. It omits any note on permissions, cost, or whether clearing the cache affects user data, which keeps it out of the top band.

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?

Behavior is front-loaded in the first two sentences, with Args and Returns sections following a predictable structure. Slightly redundant (the compile-fail behavior appears before the Args block and could be tighter), but every sentence 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?

There is no output schema, so the description correctly documents the return shape (dict with ok, compile_errors, lint_warnings, raw_output). Combined with the short-circuit behavior and both parameters documented, it is largely complete, with only permission/error-mode details missing.

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

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

Schema description coverage is 0%, so the description must compensate, and it documents both parameters: project_path as the absolute path to the Ren'Py project root, and force as clearing the .rpyc cache with default True. That is nearly complete semantic coverage, though it adds no guidance on edge cases such as relative paths.

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 compound verb+resource: run compile then lint in one call, returning a combined result. This distinguishes it from the sibling tools tool_compile_project and tool_lint_project by making clear it is the merged operation, so an agent can select it without opening either schema.

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

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

Usage is implied: 'in one call' and the short-circuit note ('if compile fails, returns immediately... no point linting broken syntax') tell the agent this is the combined path. However, it never explicitly says when to prefer this over calling tool_compile_project and tool_lint_project separately, nor names those alternatives.

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

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

With no annotations, the description carries the full burden and does so well: it discloses the exact failure mode (string-only files silently leave dialogue untranslated), the runtime-error risk of duplicate old strings, and what it scans for. It does not state whether the check is read-only/local, but for a project-analysis tool that is a minor omission.

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 one-line purpose and the headline bug, then the detail. The middle 'most important check' paragraph is somewhat verbose but every clause adds diagnostic value; nothing is pure 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?

Although there is no output schema and no annotations, the description explicitly documents the return dict shape ({ok, source_language, languages:[...]}) and issue severities. Combined with complete parameter docs, an agent has everything needed to call and interpret 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 coverage is 0%, so the description must compensate, and it does: it specifies that project_path is an absolute path to the Ren'Py project root and that language is a language code whose None value triggers checking all languages under game/tl/. Both parameters and the default behavior are fully explained.

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 ('Deep-check translation coverage') and immediately narrows it with the concrete class of bug it catches. It is clearly distinguishable from sibling list/lint tools like tool_list_translations, which merely enumerate rather than diagnose.

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 establishes a clear context ('Deep-check' vs the lighter tool_list_translations implied sibling) and explains why it matters (silent bugs left in source language). It does not explicitly name when to prefer it over tool_check_language_picker or tool_check_project, so exclusion guidance is inferred rather than stated.

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

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

With no annotations, the description carries the full burden and mostly succeeds: it says the compiler runs over all .rpy files and that failures produce structured errors with file paths and line numbers, and it explains what force does (clearing the .rpyc cache). It does not disclose that successful compilation writes .rpyc artifacts or any cost/duration characteristics, which is the remaining 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?

Front-loaded purpose sentence, then compact Args/Returns sections with no filler. Every line adds information an agent would otherwise have to guess.

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?

No output schema exists, and the description compensates by spelling out the return dict shape (ok, errors with file/line/message, raw_output). Combined with the full parameter documentation and error semantics, the definition is close to self-sufficient; only the missing sibling differentiation keeps it short of complete.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: project_path is pinned as an absolute path to the project root, and force is explained as clearing the .rpyc cache so file changes are picked up. Both parameters gain meaning beyond their bare schema types and defaults.

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

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

States a specific verb and resource ('Compile a Ren'Py project') and adds scope ('validate syntax', 'all .rpy files'). However, it never distinguishes itself from closely related siblings such as tool_lint_project and tool_check_project, so the agent can't route between them 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?

There is no explicit when-to-use guidance and no mention of alternatives. The implied 'validate syntax' framing hints at a pre-run check, but with three overlapping validation siblings (compile/lint/check) present, the absence of any disambiguation is a real gap.

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

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

With no annotations, the description carries the full burden and does disclose useful behavior: auto-creating subdirectories and auto-prefixing 'game/' to dest. It does not state whether an existing destination file is overwritten, whether failures are raised or returned via the ok flag, or any permission constraints — material gaps for a filesystem write.

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

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

Front-loaded with the core action, then structured Args/Returns blocks that are easy to scan. The second sentence partially restates the first, but overall it is well-organized with little waste.

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 and no output schema, the description supplies the return shape ({ok, message, dest_path}) as well as parameter formats, which covers most of what an agent needs. The remaining gap is overwrite/error semantics on an existing destination.

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

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

Schema description coverage is 0%, but the description compensates well by documenting all three parameters: project_path as an absolute path to the project root, source as an absolute on-disk path, and dest as a relative path within the project with an example. It adds the absolute-vs-relative distinction the bare schema lacks, though the project_path boundary (game dir vs root) could be stated more sharply.

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 (copy) and resource (asset file) plus the target (a Ren'Py project), and names the asset kinds it handles (image, font, audio). It is unambiguous and distinguishable from the inspection/lint siblings like tool_lint_project or tool_read_script.

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 establishes the context of use ('copies a file from anywhere on the system into the project's game directory'), which implies when to reach for it. However, it never states when not to use it, what happens if the destination already exists, or how it relates to sibling tools, so guidance remains implied rather than explicit.

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

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

With no annotations, the description carries the burden and does well: it discloses auto-creation of missing files, BOM preservation, that auto_compile triggers a compile after writing, and that auto_cjk_font causes font side effects, plus the return dict shape. It could go further on overwrite/replace semantics being destructive and any permission requirements, but the behavioral disclosure is substantially above baseline.

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 purpose, then uses a clean Args/Returns structure with the position modes listed inline. It is somewhat long, but nearly every sentence (auto-create, BOM, side effects) earns its place, so waste is minimal.

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 tool with no annotations and no output schema, the description is complete: it covers file creation behavior, encoding handling, the full parameter surface, and explains the return dict keys. Nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 0%, so the description must compensate and it does: it defines each parameter and enumerates all seven 'position' modes (end/top/inside/after/before/replace/replace_all) with their exact meaning, plus the defaults and side-effect intent of auto_compile and auto_cjk_font. This adds meaning far 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+resource ('inject arbitrary Ren'Py code into a project file') and explicitly positions itself as the 'universal escape hatch' tool. An agent can immediately tell this apart from siblings like tool_auto_fix, tool_compile_project, and tool_read_script, which are narrower.

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 concrete use cases (define characters, declare images, create screens, add dialogue, write init python blocks) and frames itself as the fallback when other tools don't cover a need. It stops short of naming the specific siblings it supersedes or a when-not-to-use condition, so it is clear but not fully directive.

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

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

With no annotations, the description carries the full burden and does well: it explains it parses jump and call statements to build a reference map, and that bad targets are detected. It stops short of noting analysis cost/limits or whether it reads the whole project, but behavior is substantially disclosed for a read-only analysis 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 core purpose is front-loaded in the first sentence, followed by a compact explanation of mechanism and use cases. The Args/Returns blocks are structured and skimmable; slightly verbose but every sentence 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?

With no output schema and no annotations, the description still tells the agent what the return dict contains (name, defined, definition, is_screen, callers, caller_count) and documents both required parameters. Nothing needed to invoke or interpret the tool is missing.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: project_path is documented as the absolute path to the Ren'Py project root, and name as the label/screen name to search for with a concrete example ("arrow_round"). Format and expected value are clear, though the accepted name formats (label vs screen syntax) could be tightened.

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 ('Find all jump/call references to a label or screen across the project') and scopes it clearly against siblings like tool_list_labels and tool_list_definitions by emphasizing references/callers rather than definitions. An agent can distinguish the tool's job 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?

Gives concrete when-to-use contexts: refactoring (find all callers before renaming), detecting dead code, and catching missing jump targets. This is clear usage context, though it does not explicitly name an alternative sibling tool or state when-not to use it.

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

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

No annotations are provided, so the description carries the full burden. It discloses path-resolution behavior (absolute or relative to project_path) and the return shape including an 'ok' flag, which hints at failure handling, but it says nothing about permissions, error cases, or supported formats.

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-sentence summary is front-loaded, and the Args/Returns blocks are compact and skimmable. Slight redundancy between the opening line and the argument notes, but nothing that wastes real space.

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

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

For a simple two-parameter read tool with no output schema, the description supplies the return keys (ok, width, height, format, file_size) and path semantics, which covers what an agent needs to call and interpret it. Absent annotations on a read-only tool is the only real gap.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: both parameters are documented, with project_path identified as the project root and image_path explicitly allowed to be absolute or relative to it. That is meaningfully more than the bare-string schema provides.

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 ('Get dimensions and format of an image file'), which is unambiguous. It doesn't distinguish itself from any sibling, but the sibling list contains mostly unrelated tools, so the risk of confusion is low.

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?

'Useful for calculating correct sprite positioning transforms' implies a use context but names no condition, prerequisite, or alternative tool. An agent gets a hint about intent without guidance on when this tool is the right call.

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 a real behavioral trait (false positives are possible) and documents the return shape in lieu of an output schema, but says nothing about side effects, whether the project is modified, or runtime cost.

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

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

Front-loaded with the core action, then a checks list, a sibling comparison, and clearly labeled Args/Returns sections. Every line earns its place and there is 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 single-parameter tool with no annotations and no output schema, the description covers purpose, scope of checks, sibling positioning, parameter meaning, and return structure. It omits only the safety/side-effect profile that annotations would normally supply.

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: 'Absolute path to the Ren'Py project root directory' adds path-type and root-directory semantics the bare schema property ('Project Path', string) lacks.

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 ('Run Ren'Py lint on a project (static analysis)') and enumerates what it detects (undefined variables, unreachable code, missing labels). It also distinguishes itself from the sibling tool_compile_project by noting it is 'more thorough than compile'.

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 clear comparative guidance against compile ('more thorough ... but may produce false positives'), which tells the agent when this is the better choice. It stops short of an explicit when-not rule or a mention of tool_check_project, another plausibly overlapping sibling.

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 scope ('scans all .rpy files') and the shape of the result, and the word 'Inventory'/'Scans' signals a non-mutating operation, but it never states read-only behavior, side effects, or performance cost explicitly.

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 purpose sentence followed by scope, use case, and Args/Returns blocks. The Returns section mildly duplicates the enumeration in the opening sentence, but overall it is well-organized with little waste.

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

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

There is no output schema, so the description usefully documents the return keys, and it defines the single required parameter. For a simple read-only inventory tool this covers what an agent needs, with only the safety profile left unstated.

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

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

With 0% schema coverage the description must compensate, and it does: 'project_path: Absolute path to the Ren'Py project root directory' adds the absolute-path requirement and the specific directory level, which the bare string schema does not convey.

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 ('Inventory all declarations in a Ren'Py project') and enumerates exactly which declaration types are returned, so the agent knows what it produces. It is distinguishable from siblings like tool_list_labels or tool_read_script, though it never explicitly contrasts itself with them.

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

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

'Useful for understanding project structure without reading every file' implies a use case and implicitly positions it against file-reading siblings, but gives no explicit when-to-use/when-not-to or named alternatives. Usage is inferable rather than stated.

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

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

With no annotations, the description carries the full behavioral burden. It communicates that this is a local docs index listing and documents the return shape, but it does not explicitly state side-effect safety, permissions, or failure behavior.

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

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

The description is short and front-loaded with the core purpose. It is slightly redundant in mentioning the return contents twice, but overall it 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?

For a zero-parameter, read-only discovery tool with no output schema, the description provides the needed purpose, usage context, and return structure. Nothing essential for correct invocation is missing.

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

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

The tool has zero parameters, so parameter semantics are not a meaningful gap. The baseline score 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?

The description uses a specific verb and resource: 'List all available documentation pages in the local docs index.' It also distinguishes this discovery tool from search-oriented siblings by saying it should be used before searching.

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 'Use this to see what documentation is available before searching' gives clear usage context and implies the alternative search_docs flow. It does not explicitly name search_docs or state exclusions, so it falls 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 burden; it discloses the return shape (dict of fixer names to {description, modifies} info), which is meaningful behavioral detail for a tool with no output schema. It does not explicitly state that the operation is side-effect free, but the 'List' framing and read-only nature make that low-risk.

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

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

Three short sentences, front-loaded with the action and resource, then the return shape, then the usage hint. No filler or redundancy.

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

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

For a zero-parameter listing tool with no output schema, the description supplies exactly the missing pieces: what is listed and the structure of the returned mapping. Nothing an agent needs to invoke it correctly 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?

The tool takes zero parameters, so the baseline of 4 applies. There is nothing parameter-wise the description needs to compensate for.

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: listing all available auto-fixers plus their descriptions and 'modifies' metadata. No sibling tool covers the same resource, and the tie to tool_auto_fix makes its role unambiguous.

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

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

It explicitly says when to use it ('before running' auto_fix) and names the related tool tool_auto_fix, which gives the agent a clear routing context. It stops short of stating when-not-to-use or any alternatives beyond auto_fix.

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

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

With no annotations, the description carries the behavioral burden and does well: it discloses that all .rpy files under project_path/game/ are scanned and that rich=True reads every label block and is slower. It also describes the returned fields, though it does not mention error behavior for invalid paths.

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 core action, followed by scan scope, return details, and parameter documentation. Every sentence adds useful information without waste.

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

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

Although an output schema exists, the description still gives enough return-context to set expectations, and it explains both parameters thoroughly. For a two-parameter read tool, nothing essential is missing.

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

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

Schema description coverage is 0%, so the description must compensate, and it fully documents both parameters. project_path is defined as the absolute project root, and rich is explained with its exact extra parsing behavior and performance cost.

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: list all labels in a Ren'Py project, with scope limited to .rpy files under project_path/game/. It is clear what the tool does, but it does not explicitly distinguish itself from the sibling tool_list_definitions.

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

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

Usage is implied by the scanning scope and the rich parameter's cost tradeoff, which helps an agent decide whether to request detailed parsing. However, there is no explicit guidance on when to use this tool versus tool_list_definitions or tool_find_references.

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

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

With no annotations, the description carries the burden and does well: it discloses that it scans game/tl/, enumerates exactly what is counted per language (files, dialogue blocks, string entries, GUI files), and surfaces the project source language. It doesn't state read-only behavior explicitly or what happens on a bad path, leaving a small 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?

Front-loaded summary sentence followed by well-labeled Args and Returns blocks; each sentence conveys concrete information. The per-key return enumeration is slightly listy but earns its place given there is no output schema.

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

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

No output schema exists, so the description must describe return values — and it does, spelling out the dict shape including every language-level field and the source_language key. Combined with the Args entry, an agent has everything needed to call and interpret this tool.

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

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

Schema coverage is 0% and the single parameter is merely typed as string, so the description's "Absolute path to the Ren'Py project root directory" is essential added meaning — it tells the agent the path must be absolute and must point at the project root, not a subfolder.

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 in a Ren'Py project), and immediately scopes it by naming the scanned directory (game/tl/) and the per-language report contents. An agent can distinguish this from tool_check_translation, which validates, versus this, which enumerates.

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?

"Use this first to see what translations exist before checking them" gives clear sequencing guidance toward a checking step, and the enumeration framing implies it precedes validation. It stops short of explicitly naming tool_check_translation as the alternative, so it's not a full 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?

No annotations are provided, so the description carries the full burden, and it does disclose the critical destructive behavior ('delete ALL save files', game restarts from 'start') versus the narrower stale-only deletion. It also outlines the return dict shape. Missing detail on whether deletion is reversible or needs confirmation, which keeps it at 4.

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, then a brief rationale paragraph, then structured Args/Returns. Every sentence adds information; nothing is repeated from the schema verbatim.

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 there is no output schema, the Returns section names the response keys (ok, action, saves|deleted, message), and the destructive semantics plus param meanings are fully covered. Nothing an agent needs in order to invoke it safely 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 coverage is 0%, so the description must compensate entirely, and it does: 'project_path' is defined as the absolute project root and 'action' is enumerated with list/clear/clear_stale plus the meaning of each mode. An agent can fill both params correctly from the prose alone.

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

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

Opens with a specific verb set and resource: 'List, clear, or clear-stale Ren'Py save files.' The three action semantics are spelled out precisely enough that an agent can distinguish this from the lint/compile/run siblings 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?

Gives clear context for when 'clear_stale' is the right choice (leftover _reload-*/_tracesave-* causing 'Could not find return label' after refactors) and warns that 'clear' restarts the game from 'start'. No explicit when-not or pointer to a sibling alternative, 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?

No annotations are provided, so the description carries the full disclosure burden. It does clarify the scope of what is returned (the entire block under the label, not just its signature), which is useful, but it says nothing about read-only semantics, behavior when the label does not exist, or whether jumps/includes are followed.

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

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

Front-loaded with the core action, then a short elaboration of the return value, then a compact args list. It is well within a reasonable size, with only mild redundancy between the opening sentence and the 'Returns the complete Ren'Py script block' sentence.

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 further explanation, and both parameters are given meaning. What is missing is the prerequisite that the label must exist and how to discover it, plus any note on error behavior for an unknown label – minor gaps for a read-only lookup 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% – properties carry only bare titles ('Project Path', 'Label Name'), so the description must compensate, and it does: project_path is specified as an absolute path to the project root, and label_name is given concrete examples ('start', 'chapter_01'). It stops short of clarifying accepted path forms or whether nested/local labels are valid.

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 ('Read the script content of a specific label') and immediately elaborates the return scope ('complete Ren'Py script block ... including all dialogue, menus, and nested logic'). This clearly separates it from siblings like tool_list_labels or tool_find_references, which enumerate rather than return script bodies.

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 guidance and no prerequisites are stated. It never tells the agent that a label name must already be known (e.g. discovered via tool_list_labels) or how this differs from tool_list_definitions or tool_find_references for locating script content. Usage is only inferable from the purpose line.

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

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

With no annotations, the description must carry the behavioral burden, and it does a fair amount: it discloses that commands run through the SDK's bundled Python, that translate 'creates block-translation skeletons' (a write side effect), the timeout default and its env-var override, and the return keys {ok, returncode, raw_output, errors}. It stops short of warning that arbitrary subcommands can mutate project files irreversibly, which matters for an open-ended executor.

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 purpose sentence, then scoping context, then worked examples, then Args/Returns. Structure is clean and every section is useful, though the compile/lint examples restate the escape-hatch framing already given in the first two sentences, adding mild redundancy.

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

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

There is no output schema, so the description's explicit listing of return keys is necessary and present. All four params are covered and usage is disambiguated. The gap is the absence of any note about side effects, error semantics, or safety for an arbitrary-command executor with no annotations.

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 documents all four parameters: project_path (absolute project root), command (CLI subcommand), args (extra arguments with a concrete example), and timeout (override, default from RENPY_MCP_TIMEOUT or 180). This is richer than the bare schema titles.

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

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

States a concrete verb+resource ('Run an arbitrary Ren'Py CLI subcommand') and immediately frames the scope as a 'generic escape hatch' for subcommands 'without a dedicated wrapper.' It explicitly contrasts itself with tool_compile_project and tool_lint_project, so an agent can distinguish it from siblings without opening a 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 explicit when-to-use conditions: subcommands lacking a dedicated wrapper (translate, rtc, add), and the specific edge case of running compile/lint with a custom timeout when the dedicated tools time out. Alternatives are named and the selecting condition is 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 full burden. It discloses meaningful traits beyond structured fields: the corpus is offline/local, the documentation is Chinese, and the return format is spelled out ({ok, query, results:[{file,title,snippet,score}], result_count}). Search is inherently non-destructive, so little else is needed, though ranking/scoring behavior is not explained.

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

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

Purpose is front-loaded in the first sentence, followed by corpus/offline notes, trigger guidance, examples, and Arg/Return documentation. The example block is somewhat long but each example clarifies a real usage pattern; the only minor noise is the 'search_docs(...)' calls using a name shorter than the actual tool name.

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 two-parameter read-only search tool with no annotations and no output schema, the description covers what is needed: purpose, when to use it, both parameters, and the return structure. Nothing an agent needs to invoke it correctly is missing, though relative ranking behavior and result limits remain 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 description coverage is 0%, so the description must compensate, and it does: query is documented as supporting both English and Chinese, and max_results as the maximum to return with a default of 5. It adds useful meaning over the bare schema but does not explain matching semantics, so it is good compensation rather than exhaustive.

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), resource (bundled Ren'Py official documentation), and scope (local copy, Chinese, doc.renpy.cn, returns most relevant sections). An agent immediately understands this is semantic doc search, but the description never names or contrasts with the sibling tool_list_doc_pages, so sibling differentiation is left implicit.

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?

'Use this BEFORE writing Ren'Py code if you're unsure about syntax, function names, or best practices' gives a clear trigger context, reinforced by six concrete query examples. It stops short of naming alternatives (e.g., tool_list_doc_pages) or stating when NOT to use it, so it is clear context without explicit exclusions.

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