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

With no annotations provided, the description must carry the burden. It states the action (writing a line to stdin), which is a clear side effect. However, it does not disclose what happens if no question is pending (e.g., error, block, or queue), whether the operation is reversible, or any other consequences. The description discloses the mechanism but lacks detail on potential failure modes or post-conditions.

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

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

The description is a single, concise sentence with no redundant words. It is front-loaded with the core action and mechanism. Every word earns its place, making it highly efficient for an agent to parse quickly.

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

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

For a simple single-parameter tool with no output schema and no annotations, the description is nearly complete. It tells the agent what to do and how. The only gap is that it does not reference the ro_prompt sibling or mention that a question must be pending first, which would help avoid misuse. However, given the low complexity, it is adequately complete for the tool's purpose.

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

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

The schema description coverage is 100%, as the 'answer' parameter includes a description ('The literal line to send, e.g. '0'.)'. The tool description adds no additional semantic detail beyond what the schema already provides. Per the baseline for high coverage, a score of 3 is appropriate—the schema handles parameter documentation fully.

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

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

The description clearly states the tool's action: 'Answer OpenKore's pending interactive question' with the specific mechanism 'by writing a line to its stdin.' It uses a precise verb (answer), a resource (the pending question), and distinguishes it from siblings like ro_prompt (which likely retrieves the prompt) and ro_command (general commands). The purpose is unambiguous.

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

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

The description provides clear context: it is for answering a pending interactive question. It implies the tool should be used when such a question exists, differentiating it from tools like ro_prompt or ro_command. However, it does not explicitly mention when not to use it or name alternative tools. It gives enough context for an agent to infer the appropriate scenario, but lacks explicit exclusions or 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?

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It only states that the tool attacks a monster, but it does not disclose side effects (e.g., whether it is destructive, consumes resources, or can fail), nor does it mention that the attack takes time (waitMs). The waitMs parameter suggests combat duration, but the description does not explain that behavior. This is a significant gap for a combat tool.

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

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

The description is a single, efficient sentence that front-loads the action and target. There is no redundant wording, and every part adds value—the verb, the source of the binID, and the context of 'nearby'. It is a model of concise tool documentation.

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 tool with no output schema and no annotations, the description gives the essential information: how to identify the target (binID from ro_state.nearbyMonsters) and the intended action. However, it omits details about the outcome or failure modes, and it does not mention the time-bounding of the attack (waitMs is only in the schema). An agent can call it correctly, but it lacks some context about what to expect, making it incomplete for a richer behavioral understanding.

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 describes waitMs with a description, but binID lacks one. The description compensates by specifying that binID comes from ro_state.nearbyMonsters, adding meaning beyond the raw integer type. Since schema coverage is only 50%, the description helps for binID, but it does not elaborate on the constraints or format of the binID. This is adequate but not thorough.

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

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

The description clearly states the action ('Attack') and specifies the target as 'a nearby monster by its binID from ro_state.nearbyMonsters'. This distinguishes it from sibling tools that deal with movement (ro_walk), dialog (ro_talk_npc), or state (ro_state). It does not merely restate the tool name; it gives a specific verb and resource. However, it could be more explicit about what 'attack' entails (e.g., initiating combat) or the outcome, so it falls just short of a 5.

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

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

The description implicitly guides usage by referencing ro_state.nearbyMonsters, indicating that users must first call ro_state to obtain a valid binID. However, it does not explicitly state when to use this tool versus alternatives, nor does it list exclusions or conditions. There is no mention of when to walk away or use other tools. The context is clear but the guidance is not explicit enough for a higher score.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without revealing side effects, error conditions (e.g., what happens if no dialog is open), or whether closing is idempotent. The description essentially restates the tool name in a fuller sentence, adding no behavioral nuance beyond the obvious.

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

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

The description is a single, compact sentence with no filler. Every word earns its place, and it is front-loaded with the action verb. Perfect for a tool this simple.

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

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

Given the tool's extreme simplicity (no params, no output schema, single action), the description might be sufficient. However, it omits any handling of edge cases (e.g., when no dialog is open) and provides no context about dialog-state dependencies. For a game automation tool, knowing whether close works without an open dialog could matter. It's adequate but not complete enough to be a strong contextual guide.

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

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

The tool has zero parameters, so the schema already conveys everything. The description adds no parameter-specific meaning, but the baseline of 4 applies because there is nothing to document. The description's only job is to confirm the action, which it does adequately.

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 clear verb ('Close') and specific resource ('currently open NPC dialog'), which differentiates it from siblings like ro_dialog_next (advance) or ro_menu_select (choose option). It is not a tautology; it adds the word 'currently' to indicate state. Slight deduction because it doesn't explicitly name a contrasting sibling, but the distinction is clear enough.

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

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

No guidance on when to use this tool versus alternatives, no mention of prerequisites (e.g., 'only when a dialog is open'), and no exclusion criteria. The sibling list includes ro_dialog_next and ro_menu_select, but the description doesn't address when to close rather than advance or select. Usage is only implied by the verb.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It merely says 'run an arbitrary command' without mentioning side effects, risks of arbitrary execution, or any state changes. Given the tool's 'escape hatch' nature, the lack of warnings or constraints is a significant 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?

The description is one concise sentence that front-loads the purpose ('Escape hatch') and provides a clear directive. It conveys maximum information with zero filler, making it highly 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 single-parameter tool with no output schema, the description covers the basic purpose. However, it lacks any caveats about the dangers of arbitrary commands (e.g., irreversible actions, unknown return formats) and doesn't mention error handling or limits. Given the tool's broad scope, more context would be helpful, but it's not incomplete to the point of being unusable.

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 100% with the 'cmd' parameter described via example ('sit', 'status', 'i'). The description adds no extra meaning beyond the schema, merely confirming the parameter is a console command. With full schema coverage, baseline is 3, and the description doesn't exceed that.

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

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

The description clearly states the tool runs an arbitrary OpenKore console command, using a specific verb ('run') and resource ('command'). It also distinguishes itself from siblings by noting 'Prefer the specific tools; use this for anything they do not cover,' which makes its niche explicit.

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 direct when-to-use guidance: 'Prefer the specific tools; use this for anything they do not cover.' This explicitly tells the agent to use specialized tools first and this only as a fallback, leaving no ambiguity about selection.

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 burden of behavioral disclosure. It only states 'Read recent console output' without noting that it is non-mutating, what the output format is, or any performance limitations. It adds minimal value beyond the basic read operation, leaving the agent to assume safety and response characteristics.

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

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

The description is two sentences with no redundancy. It front-loads the core action and then adds a practical usage hint. Every word earns its place, making it optimally concise and well-structured.

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

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

For a simple read tool with one optional parameter and no output schema, the description gives the essential action but does not describe the output format, potential size limits, or any edge cases. It is adequate for basic usage but not thorough—an agent knows what it does, but not what the response will look like.

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 fully documents the only parameter 'lines' with a description ('How many trailing lines'), default, min, and max. The tool description adds no extra meaning about this parameter. With 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the verb and resource: 'Read recent OpenKore console output.' This distinguishes it from sibling tools like ro_walk or ro_attack, which are actions, and ro_state, which reports state. The added usage context ('when something did not behave as expected') further clarifies the intended purpose.

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

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

The description provides a clear usage scenario, telling the agent to use this when something did not behave as expected. It does not explicitly mention alternatives or exclusions, but the context is specific enough that an agent can infer when to choose this over siblings. Lacking an explicit 'when not to use' prevents a perfect score.

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 discloses the state dependency (that it only works during a specific prompt), which is a critical behavioral trait. It does not, however, describe side effects, error behavior, or what happens if the precondition is violated. For a mutation tool (creating a character), this is a moderate gap, but the core limitation is stated.

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 clauses in a single sentence, with the purpose front-loaded and the usage constraint appended. No unnecessary words, every part earns its place. It is minimally verbose while conveying the essential 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?

Given the tool's complexity (6 parameters, no output schema, no annotations), the description is sparse. It doesn't mention what happens after successful creation, any return values, error conditions, or how to handle slot conflicts. The prerequisite hint about ro_prompt is useful but is the only piece of operational context. An agent would need to infer most behavior from the name and schema alone, which is inadequate for a state-dependent creation action.

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

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

Schema description coverage is only 17% (only 'name' has a description in the schema). The tool description adds no explanation of any parameter, failing to compensate for the low coverage. It doesn't clarify what 'slot' means in context, what job/sex options imply, or the significance of hairColor/hairStyle. The agent must infer meaning from enums and names, which is insufficient for a 6-parameter tool.

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

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

The description states the action clearly ('Create a character') and specifies the target resource (the given slot). It does not differentiate from the sibling ro_select_char, which also deals with characters, but the verb 'create' implies a distinct operation. Since it doesn't explicitly contrast with any sibling, it loses the point for clear 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 an explicit condition for valid usage: only while OpenKore is asking for character properties, and it instructs to call ro_prompt first to confirm. This provides a clear when-to-use rule and even names a prerequisite tool. However, it doesn't mention when not to use it or alternatives, but the condition is strong enough to guide an agent.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says the tool 'advances' a dialog, but does not explain side effects (e.g., does it block? does it return dialog text? does it require the dialog to be in a specific state?), prerequisites, or failure modes. For a tool that modifies dialog state, this is insufficient transparency.

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

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

The description is a single, clear sentence with no filler or redundancy. It is appropriately concise for the scope of action, though it omits important details that are scored elsewhere. Structurally, it is front-loaded with the core action and context, which is good.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description could be considered sufficient for a basic 'click' action, but it leaves out critical context: what preconditions must hold (e.g., is a dialog currently open and waiting?), what timeoutMs influences, and whether there are any side effects like advancing multiple steps. With no annotations or output schema, the agent is left with ambiguous assumptions about how 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?

The schema has a single parameter timeoutMs with 0% description coverage, meaning the schema provides no documentation for it. The description does not mention the parameter at all, leaving the agent to guess its purpose. Given the low coverage, the description must compensate, and it fails to do so. Even a brief note like 'timeoutMs controls how long to wait for the dialog to advance' would be minimal.

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 ('Advance') and resource ('NPC dialog') with a clear condition ('waiting on a 'next' click'). This distinguishes it from sibling tools like ro_talk_npc (initiate dialog), ro_close_dialog (close), and ro_menu_select (select menu). An agent can easily determine this is the 'continue/next' action in a dialog flow without ambiguity.

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

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

The description implies the tool should be used when an NPC dialog is waiting for a 'next' click, but it does not explicitly state when to use it versus alternatives, nor does it provide any exclusions or conditions. For example, it does not clarify whether it is appropriate only after ro_talk_npc or how it differs from ro_menu_select or ro_answer. An agent would need to infer usage based on the name and context.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses the permission requirement and the key behavioral difference from ro_warp (no route needed). It does not cover side effects like destination defaults or behavior when coordinates are omitted, but for a teleport command, the essentials are present. It is transparent about the privileged nature and the lack of path requirement, which is sufficient for an agent to anticipate outcomes.

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

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

The description is two sentences, front-loaded with the core action and the most critical fact (permission). The differentiator is placed second, and every sentence adds value. There is no fluff or repetition, making it extremely concise and well-structured.

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

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

The tool is a simple teleport, but it has 4 parameters (only 1 required) and no output schema. The description covers the essential purpose and the difference from ro_warp, but fails to explain the optional parameters (x, y, timeoutMs) which are likely important for precise teleporting. Given the low schema coverage, this is a notable omission. The description is complete enough for a basic call but not for a full correct invocation if coordinates or timeouts are needed.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It only implicitly covers 'map' (the destination), but does not mention 'x', 'y', or 'timeoutMs'. A user would not know that coordinates can be specified or what timeoutMs does. This is a significant gap since the schema itself has no descriptions. The description adds some meaning to the map parameter but fails to compensate for the undocumented parameters.

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

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

The description explicitly states the verb 'Teleport' and the resource 'map', and names the specific GM command '@warp'. It also contrasts with the sibling ro_warp, making it unambiguous which tool is which. This is a strong, specific purpose statement that distinguishes it from other tools.

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

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

The description provides explicit when-to-use guidance by contrasting with ro_warp: 'Unlike ro_warp this needs no walkable route, which matters because some maps (the tutorial grounds, instances) have no path out.' It also mentions the permission requirement (GM group with @warp permission), which is a clear prerequisite. This fully covers usage context and alternative selection.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It only says 'choose an option' without mentioning that selecting advances the menu, possibly ends a dialog, or requires an active NPC interaction. Side effects and prerequisites are omitted.

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, concise sentence that front-loads the core action and index semantics. No unnecessary words or repetition.

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

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

For a state-changing tool with no output schema and no annotations, the description is too minimal. It omits prerequisites (e.g., an active NPC menu), what happens after selection, and any return value or side effects. The referencing of ro_talk_npc is the only contextual anchor.

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 50% (only 'index' has a description). The description adds no information about 'timeoutMs' and merely restates the zero-based indexing already present in the schema. It fails to compensate for the undocumented parameter.

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

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

The description clearly states the verb 'choose' and the resource 'option from the NPC's menu', and specifies the zero-based indexing. Though it does not explicitly differentiate from siblings like ro_dialog_next, the parameter reference to ro_talk_npc ties it to a specific preceding action, so the purpose is effectively distinct.

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

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

Usage context is implied by the parameter description ('options from ro_talk_npc') but not stated directly. The description does not mention when to use it versus alternatives (e.g., ro_dialog_next) or any exclusions, leaving the agent to infer it should follow an NPC conversation.

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 the tool is a check (non-mutating) and that the main loop is stopped while a prompt is pending, which is useful context. However, it does not specify the return format (e.g., boolean, status object) or any error conditions, leaving the agent to guess what the tool actually returns. Given the absence of an output schema, this is a notable 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?

The description is two sentences with zero waste. The first sentence states the exact purpose, and the second provides essential operational context (timeout and resolution). It is front-loaded with the most important information and does not repeat schema or annotations. Every word earns its place.

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

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

For a tool with no parameters and no output schema, the description covers the purpose, behavioral implications, and relation to siblings. However, it omits the return value specification entirely; an agent cannot know whether the tool returns a boolean, a status string, or something else. This is a critical missing piece for a tool that is purely a check, especially without an output schema to fill the gap.

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

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

The tool takes zero parameters, and the schema coverage is 100% (empty properties). The description correctly makes no mention of parameters, and with no params to explain, there's nothing to add beyond the schema. The baseline for 0 params is 4, which is appropriate here.

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 ('Check whether') and a specific resource ('OpenKore is blocked on an interactive question'), with concrete examples of the question types (character creation, selection, password retry). It clearly distinguishes this from siblings like ro_answer (which resolves the prompt) and ro_state (likely a global state check), so an agent can immediately understand its unique role.

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 states when to use the tool (to check for a pending prompt) and explains the consequence of a pending prompt: 'every other tool will time out until it is answered with ro_answer.' This implicitly instructs the agent to call this tool first to avoid timeouts, and it names the alternative (ro_answer) as the resolution path. No ambiguity remains about timing or alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'enter the world' implying a state change, but it doesn't specify side effects, required prior conditions, error handling for invalid slots, or what happens if no character exists. This is minimal disclosure for a state-changing operation.

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

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

The description is a single, efficient sentence with no redundant wording. It front-loads the core action ('Select a character') and immediately explains the result. However, it is on the edge of under-specification, but for a one-line description it avoids fluff and gets to the point.

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 only one parameter, no output schema, and no annotations, the description is incomplete. It doesn't mention when it should be used (e.g., after starting the game, after character creation), whether it requires prior login state, or what failures might occur (e.g., invalid slot). An agent would need to infer these from sibling tool names, which is not sufficient.

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

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

The single parameter 'slot' is self-explanatory and the schema defines its integer range and default. The description repeats 'slot number' without adding further meaning or context (e.g., that slot indices correspond to character list order). Since schema coverage is 0% but the parameter is trivial and well-typed, a baseline of 3 is appropriate; the description does not need to overexplain.

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

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

The description clearly states the action ('Select a character by its slot number') and the outcome ('enter the world'), providing a specific verb and resource. It distinguishes the action from other character-related tools like ro_create_char, though it doesn't explicitly name alternatives. The phrasing is unambiguous and directly tied to the tool's function.

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

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

No guidance is provided on when to use this tool versus siblings. It doesn't mention prerequisites like needing to start the game first (ro_start), having characters available, or that this is for selecting an existing character after creation. The description gives no context for appropriate invocation or alternatives.

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

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

With no annotations provided, the description must disclose behavioral traits itself. It does: it states the launch-and-connect action, and specifies the return value ('game state' or 'pending prompt if login needs an answer'), which reveals a potential interactive step. It doesn't cover failure modes or idempotency, but for a start operation this is adequate.

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 sentences with zero waste. The action is front-loaded, the critical ordering constraint comes next, and the return behavior finishes. Every sentence earns its place.

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

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

For a zero-parameter start tool with no output schema, the description covers the launch action, the ordering requirement, and the return behavior (including the edge case of login prompt). An agent has everything needed to call it correctly and understand what to expect. The structure of the game state itself is likely the domain of ro_state.

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

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

The tool has zero parameters, so the schema covers all parameter semantics trivially (100% coverage). The description adds no parameter-specific detail, which is appropriate. Per the rubric, a zero-parameter tool earns a baseline 4.

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

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

The description states a specific verb ('Launch') and resource ('OpenKore' and 'local rAthena server') and explicitly declares it as the entry point ('Must be called before any other tool'). This distinguishes it from sibling tools like ro_stop or ro_state, making purpose unambiguous.

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

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

The instruction 'Must be called before any other tool' is an explicit, unambiguous usage guideline. It clearly tells the agent when to use this tool relative to all others in the sibling set, which is exactly the context needed for an orchestration tool.

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. 'Read' conveys a non-destructive snapshot operation and the sentence lists what data comes back, which covers the core behavior. It does not disclose staleness/latency semantics or whether the return is a one-shot snapshot, but for a simple read tool the essential trait (read-only, live) is stated.

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 clean sentence that front-loads the verb and resource before listing contents. No wasted words; the only slight inefficiency is the run-on enumeration ('character stats and position'), but it remains efficient and readable.

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 0-param, no-output-schema read tool, the description lists all the major data categories an agent needs to know it returns (connection, map, stats, position, nearby entities). The only gap is the absence of return-format/structure details, which would require an output schema or additional description, but the tool is simple enough that this is a minor shortfall.

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

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

The tool has zero parameters and schema coverage is trivially 100%. Per the rubric, a 0-param tool benchmarks at baseline 4; there is nothing for the description to explain about parameters.

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

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

The description states a specific verb ('Read') plus a concrete resource ('the live game state') and enumerates the contents: connection, map, character stats and position, and nearby NPCs/monsters. This clearly distinguishes it from the action-oriented siblings (ro_walk, ro_attack, ro_warp) and the dialog tools.

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

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

The reading/scoping nature of the tool makes its place among siblings clear by implication (inspect state before acting), but the description gives no explicit when-to-use guidance and names no alternatives or exclusions. It does not say 'use this to check state before choosing an action,' which would have helped.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action ('Shut down') without explaining what happens to the session, processes, or any potential irreversible effects. This is insufficient for a destructive operation.

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

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

A single, focused sentence conveys the entire tool purpose with no wasted words. It is appropriately sized for a parameterless tool and front-loads the action.

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

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

The description is minimal but adequate for a simple tool. However, it lacks any mention of consequences (e.g., termination of processes, unsaved state) or relationship to other tools like ro_start. Given the absence of annotations and output schema, more context would be helpful.

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

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

The tool has zero parameters and the schema coverage is 100% (empty schema). The description correctly adds no parameter details, matching the baseline of 4 for no-parameter tools.

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

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

The description uses the verb 'Shut down' and the resource 'OpenKore session,' which clearly states the tool's action. It distinguishes from siblings like ro_start (opposite) and ro_state (status), but does not elaborate on the implications of shutdown.

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it does not mention that ro_stop should be used to terminate a session started by ro_start, nor does it note any prerequisites or side effects.

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

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

With no annotations, the description carries the full burden. It discloses the return content (dialog text and menu options) but omits side effects like whether dialog opens, if the character must be in proximity, or if the call blocks until a response. The existence of timeoutMs implies waiting, but that isn't described.

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 concise sentences, front-loaded with the main purpose and output, followed by parameter identification. No redundant phrasing or unnecessary details.

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

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

For a tool with no output schema and no annotations, the description should cover the targeting contract (one of binID/coordinates), the timeout semantics, and how this fits into the dialog flow. Only the output and identification methods are given, leaving significant context gaps for an agent to call it correctly.

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

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

Schema coverage is only 25% (only binID has a description). The description adds meaning for x/y ('map coordinates') and binID ('from ro_state'), but timeoutMs is left undocumented. It also doesn't clarify whether binID and coordinates are mutually exclusive or if at least one is required, which is essential for correct invocation.

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

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

The description states a clear verb ('talk to') and resource ('NPC'), and specifies the output: 'dialog text plus any menu options.' It also names two identification methods (binID or map coordinates), which distinguishes it from the other dialog tools like ro_dialog_next or ro_menu_select.

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 vs siblings such as ro_dialog_next, ro_close_dialog, or ro_menu_select. It only explains how to identify the NPC, not the conversational context or that this is the initial dialog action.

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 discloses that it waits until arrival, but does not mention what happens on failure (e.g., unreachable path), whether it can be interrupted, whether it requires a specific character state, or what the tool returns. This is insufficient for a tool with no structured hints, as the agent cannot anticipate side effects 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 a single, concise sentence with no fluff. It front-loads the primary action and the waiting condition. While it is under-specified, conciseness itself is not a flaw—it is appropriately brief. It could be expanded with more details without becoming verbose, but the current length is efficient and waste-free.

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

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

Given four parameters (two required) and no output schema, the description falls short of what an agent needs to call the tool reliably. It does not describe return values, error handling, or edge cases (e.g., unreachable coordinates). The lack of detail on x/y ranges and timeout behavior makes it incomplete, especially since the schema does not provide these details either.

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 only 25% (only tolerance has a description). The tool description says 'coordinates' but does not define the coordinate system, units, or valid ranges for x and y. timeoutMs is not explained at all. The description does not compensate for the low schema coverage, leaving significant ambiguity about how to correctly populate the parameters.

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

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

The description clearly states the action (walk) and the target (coordinates on the current map) and includes the deferral (wait until arrival). This is specific and unambiguous. However, it does not explicitly distinguish this from sibling tools like ro_warp, leaving the agent to infer that 'walk' implies a different behavior than teleporting. A 5 would require explicit differentiation, so a 4 is appropriate.

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 instead of ro_warp or other movement-related commands. The description only states what the tool does, not the conditions under which it is the appropriate choice. It does not mention alternatives or exclusions, so an agent has to infer usage from context. This falls below the 'implied usage' level because there is no hint about when walking is preferable to other methods.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool uses OpenKore's route planner and that the path must exist, which hints at a failure mode. However, it does not explain side effects (e.g., loading screens, state changes), whether the call blocks, or what happens on success/failure. Minimal disclosure for a movement tool with no annotation safety net.

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

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

The description is a single, tightly worded sentence with no fluff. It front-loads the core action and adds a relevant caveat. It is appropriately concise for what it is, though it may be too terse for the context (penalized in other dimensions).

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

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

The tool has four parameters, only one required, and no output schema or annotations. The description does not clarify the purpose of x/y (are they optional coordinates?), the timeout semantics, or what the caller should expect in return (e.g., success/failure indication). Given the complexity and sparse structured metadata, the description is insufficient for an agent to reliably invoke the tool with correct parameters and 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 coverage is only 25% (only map has a description). The tool description adds nothing about x, y, or timeoutMs—it does not explain that x/y are likely target coordinates within the map or that timeoutMs controls how long to wait for arrival. The phrase 'by name' only reiterates the map parameter already described in the schema. The description fails to compensate for the low schema coverage.

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

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

The description clearly states the verb (Move) and resource (another map) and specifies that it is by name. It also adds a technical detail (uses OpenKore's route planner). However, it does not explicitly differentiate from siblings like ro_walk or ro_gm_warp, though 'by name' and map context make it distinct enough. Not quite a 5 because no sibling is named.

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 ro_walk (within-map movement) or ro_gm_warp (likely GM-specific). The only practical note is that the path must exist, which is a precondition, not a usage guideline. The agent is left to infer when this is the right choice.

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