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

Annotations already signal destructive behavior, but the description adds useful operational details beyond them: destroying puts blocks into the backpack, repeat allows consecutive executions, and direction is relative to the agent's facing. It also notes the agent is Education Edition exclusive and requires creation first. This gives an agent a clear behavioral model without contradicting the annotations.

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 compact and front-loaded, with the main action semantics in the first sentence, then a note on repeat, a prerequisite, and a critical direction clarification. Each sentence earns its place, and there is no redundant repetition of the schema.

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

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

Given the tool has an output schema and the annotations already cover destructive intent, the description provides all necessary context for correct invocation: the prerequisite of mc_agent_create, the precise meaning of each action, the direction reference frame, and repeat behavior. An agent can confidently select and call this tool without needing additional information.

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

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

Schema description coverage is 0%, so the description must compensate. It does well by explaining the three action enum values (attack, destroy, till) and the meaning of direction (relative to agent facing). It also clarifies that repeat can be used for continuous execution. The delayMs parameter is not mentioned, but its meaning is self-evident from its name and schema defaults. Overall, it adds substantial meaning beyond the raw schema.

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

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

The description clearly states the tool performs three specific actions (attack, destroy, till) on a specified direction, distinguishing it from siblings like mc_agent_move or mc_agent_place. It even explains the effect of each action (e.g., destroy collects blocks into backpack) and clarifies the direction is relative to the agent's facing, leaving no ambiguity about what the tool does.

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 for when to use the tool: when the agent needs to attack, destroy, or till. It also includes a key prerequisite (must use mc_agent_create first) and explains direction semantics. However, it does not explicitly mention alternatives or when not to use it, but the action list itself implies the appropriate use cases.

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

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

Annotations provide no positive hints (all false), so the description carries the burden. It does add useful context: Agent is Education Edition-only, must be summoned first, and direction is relative to Agent facing. However, it does not disclose the mutating effect on the world or inventory, failure modes, or behavior when no items match.

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 purpose, followed by parameter behavior, prerequisite, and orientation caveat. Every sentence contributes, though the direction note is only marginally relevant to a collect 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?

Given a simple 1-optional-parameter tool with an output schema present, the description is largely complete: purpose, optional parameter semantics, and the Education Edition/Agent-creation prerequisite are covered. Minor omissions like collection range or no-drop behavior do not seriously hurt usability.

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% and already defines item as a block ID with a null default, so baseline is 3. The description adds meaning beyond the schema by explaining that an empty item value collects all items, which is significant for the single 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 states a specific verb and resource: 撿取 Agent 附近的掉落物 (collect dropped items near the Agent). This clearly distinguishes it from sibling tools like mc_agent_inventory, mc_agent_sense, or mc_give, whose purposes are different.

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 explicit usage context: item left blank means collect all, and the Agent must first be created with mc_agent_create. It also notes Education Edition exclusivity. It does not explicitly name alternative tools or state when not to use it, so it stops 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?

Annotations already declare idempotentHint=true, and the description reinforces this by saying repeated calls are safe. It additionally discloses useful behaviors not in the structured fields: the Agent spawns beside the player, is Education Edition-exclusive, and the direction semantics are relative to the Agent's own facing rather than world orientation.

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 brief, front-loads the core action, and packs idempotency, edition exclusivity, prerequisite usage, and directional behavior into three sentences. It is not perfectly structured because the sentence '必須先用 mc_agent_create 召喚' is mildly self-referential, and the direction note is cryptic given that the tool has no input parameters.

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

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

For a parameterless, idempotent, non-destructive creation tool with an output schema, the description covers everything needed: what is created, where it appears, that it is repeat-safe, that it is Education Edition-only, and that it is the required prerequisite for Agent operations. No essential call context is missing.

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

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

The tool has zero parameters and the schema documents that fully, so the description has no parameter semantics to add. The directional note appears to describe Agent behavior rather than any input, and there is no schema gap needing compensation.

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: '生成 Agent' next to the player, and it identifies the Agent as an Education Edition-specific robot. It does not explicitly contrast this tool with sibling alternatives such as mc_summon, so it stops just short of the top score.

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

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

The description gives strong usage context by saying the Agent must be summoned with mc_agent_create first, and that repeated calls are safe. It also notes the Education Edition-only restriction, but it does not explicitly name alternative tools for non-Agent entities or state when not to use this tool beyond that restriction.

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

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

Annotations are all false, so the description carries the burden. It reveals the direction relativity (important behavior) and lists actions, but it does not disclose consequences like whether dropping items removes them permanently or places them in the world, nor does it mention error handling or side effects. The term '清空整槽方向' is ambiguous about what happens to the items. Some transparency is provided, but significant gaps remain.

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 concise (two sentences) and front-loads the action list. It avoids redundancy, though the first sentence is a long enumeration that could be structured more cleanly. Overall it is efficient and effective.

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 an output schema present, the return format is known. The description includes the prerequisite, direction semantics, and action list, covering key aspects for a multi-action tool with 5 parameters. It lacks discussion of error cases, permissions, or detailed side effects, but given the output schema and clear prerequisite, it is reasonably complete.

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

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

Schema coverage is 80%, which provides baseline, but the description adds value by mapping actions to parameters (e.g., 'count 查槽內數量') and clarifying that direction is relative to Agent's facing, not world orientation. This goes beyond the schema's enum listing. It also explains the necessity of mc_agent_create, aiding parameter interpretation.

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 specifies the tool operates on the Agent backpack with a clear list of actions (count, space, detail, drop, dropAll, transfer), each with a brief meaning. It also explicitly states a prerequisite (Agent must be summoned with mc_agent_create) and clarifies a key distinction from world coordinates (direction relative to Agent's facing). This is a specific verb+resource description that differentiates it from siblings like mc_agent_act or mc_agent_move.

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 clearly states the prerequisite of using mc_agent_create and defines the tool's scope as Agent backpack operations. However, it does not explicitly mention when not to use it or name alternative tools for similar tasks. It provides clear context for invocation but lacks explicit exclusions.

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

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

因 annotations 全為 false，描述承擔了行為透明度的責任。它揭露了被方塊擋住時該步會失敗但不會中斷後續，以及每格一條指令的特性，超越了 annotations 提供的資訊。

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?

三句話簡潔扼要：先講動作，再講失敗行為，最後講前置條件與方向定義。每句都有價值，無冗詞。

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?

涵蓋了核心資訊：動作內容、失敗處理、前置條件及方向相對性。雖然未提及回傳值，但輸出 schema 存在，因此足夠完整。

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 描述覆蓋率僅 33% (只有 delayMs 有描述)，描述補充了 steps 代表的格數與 direction 的相對面向語意，有效填補了未描述參數的缺口。delayMs 則由 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?

明確的動詞與資源 (讓 Agent 走 steps 格)，指出是 Agent 專用移動工具，並提及需先召喚，與 mc_agent_teleport 等兄弟工具明顯區隔。

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?

明確指出前置條件 (必須先用 mc_agent_create 召喚)，並解釋方向是相對自身面向而非世界方位，提供實際使用情境。但未直接說明與其他移動方式 (如 teleport) 的比較。

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

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

Annotations (readOnlyHint: false, destructiveHint: false) indicate this is a mutating but non-destructive operation. The description adds meaningful behavioral details beyond annotations: it discloses that the tool fails if the slot is empty, that the Agent must be created first, and that direction is relative to the Agent's facing. These are operational constraints an agent needs to know. It does not mention repeat or delay behavior, but the annotations do not contradict the description.

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

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

The description is a compact three-sentence structure that front-loads the core action, then covers failure conditions, prerequisites, and a direction nuance. Each sentence delivers discrete, non-redundant information, and no space is wasted. This is appropriately sized for the tool's complexity.

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

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

Given that an output schema exists (so return values are documented) and annotations are present, the description covers the essential operational context: the prerequisite to create the Agent, the failure mode when the slot is empty, and the relative-direction semantics. It omits explicit mention of the repeat and delayMs behavior, but these are less critical for correct invocation. Overall, it is sufficiently complete for a moderately complex tool, with minor gaps around loop timing.

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

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

The schema has 0% parameter descriptions, so the tool description must compensate. It adequately explains the 'slot' parameter (range 1-27, failure when empty) and the 'direction' parameter (relative to agent, six options). However, it provides no semantic clarity for 'repeat' and 'delayMs' parameters beyond what the schema's defaults and bounds convey. Since two of the four parameters are left unexplained, it only partially compensates for the missing schema documentation.

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 ('take a block from the specified inventory slot (1-27) and place it in the specified direction') with a specific verb, resource (agent's inventory slot), and destination (direction). It also distinguishes itself from related block-placement tools by specifying that it operates through the Agent robot, which is exclusive to Education Edition, and that it requires prior creation via mc_agent_create.

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 usage context: it explicitly states the prerequisite that the Agent must be summoned with mc_agent_create, and it notes the critical behavioral distinction that direction is relative to the Agent's own facing, not the world orientation. However, it does not explicitly name or contrast with alternative block-placing tools like mc_set_block or mc_fill, leaving some ambiguity about when to prefer this tool over those.

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?

Beyond the destructiveHint annotation, the description discloses sequential execution, per-step result reporting, and configurable stop-on-failure behavior. It does not detail the exact side effects or failure semantics, but adds meaningful behavioral context beyond the annotations.

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 a clear front-loaded definition, followed by memorable use-case examples and the two most important behavioral switches. 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?

Given the highly detailed union schema and existing output schema, the description covers the tool's core role, examples, sequencing, per-step output, and failure policy. It omits prerequisites such as agent existence and parameter details, but those are less critical for selecting and invoking the tool.

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

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

The description partially compensates for low schema coverage by clarifying that 'steps' are a chain of Agent actions and that stop-on-failure is configurable. It does not explain delayMs or the action object structures, leaving the rich item-level schema to carry most parameter meaning.

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

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

The description clearly defines the tool as executing a sequence of Agent actions as a program, with concrete examples such as paving while walking, digging a tunnel, and tilling a field. It distinguishes the batch/program nature from single-action siblings, though it does not explicitly name an alternative.

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

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

It provides clear context for when to use it: any multi-step, task-oriented Agent behavior, and calls it the main tool for making the Agent actually do things. It gives representative use cases, but does not explicitly say when to prefer single-action sibling tools.

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

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

The description reinforces the non-destructive nature ('不改變世界') and adds specifics beyond the annotations: inspect returns block type, inspectData returns data values, detect checks for solid blocks, and detectRedstone checks redstone signals. These details align perfectly with readOnlyHint/idempotentHint and provide actionable behavioral expectations.

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 three sentences with no fluff. It front-loads the core purpose and safety property, then efficiently enumerates the modes, ending with a memorable usage metaphor. 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?

Given the availability of an output schema and comprehensive annotations, the description covers all necessary context: what each mode does, that it is non-destructive, and when to use it. For a sensing tool with two enum parameters and no required fields, nothing critical 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?

With 0% schema description coverage, the description takes on full responsibility for explaining the mode parameter. It explicitly defines each enum value, which is the critical parameter. The direction parameter values (forward/back/left/right/up/down) are self-explanatory standard directions, so no additional description is needed.

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

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

The description clearly states the tool reads the Agent's surroundings and does NOT change the world, listing four specific sensing modes (inspect, inspectData, detect, detectRedstone) with distinct purposes. This differentiates it from action-oriented siblings like mc_agent_act or mc_agent_move, making the tool's 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?

The phrase '這是 Agent 的「眼睛」，行動前先看' provides clear context: use this tool as a pre-action sensing step. While it doesn't explicitly compare against alternative read tools like mc_read_block or mc_query_target, it establishes a clear usage heuristic and when to invoke it (before acting).

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

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

The description adds behavioral context beyond the annotations, noting the Agent is Education Edition exclusive, requires prior creation with mc_agent_create, and that direction is relative to the Agent's facing rather than world coordinates. The annotations (idempotentHint=true, destructiveHint=false) already cover the safety profile, so the description adds value without contradiction.

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 deliver the action, use cases, prerequisite, and a directional caveat without redundancy. Each sentence earns its place, and the main action is front-loaded.

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

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

With no parameters, an output schema present, and the description covering purpose, usage conditions, prerequisite, and a subtle behavioral detail, an agent has everything needed to call the tool correctly.

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

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

The input schema has zero parameters, so the description does not need to explain parameter formats; the baseline of 4 applies since there is nothing to clarify.

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 opens with a specific verb and resource ('把 Agent 叫到玩家旁邊' – call the Agent to the player's side) and reinforces the purpose with the recovery use case ('Agent 走丟、卡住或掉進洞裡時用這個回收'). This clearly distinguishes it from sibling tools like mc_agent_move (targeted movement) and mc_teleport (general entity teleportation).

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

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

It provides explicit conditions for use ('走丟、卡住或掉進洞裡時') and a prerequisite ('必須先用 mc_agent_create 召喚'), giving an agent clear context on when to invoke it. It does not explicitly name alternatives, but the use-case restrictions and prerequisite are sufficient for 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?

Annotations are all false and provide no real safety profile, so the description carries the behavioral disclosure burden. It discloses the core effect (rotate in place 90 degrees), the times=2 about-face behavior, and the relative-to-self orientation semantics. It omits failure modes or world interaction, but for a simple turn action 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?

Three sentences, each earning its place: core action with degrees, times semantics, prerequisite, and coordinate-frame clarification. There is no filler, repetition of schema fields, or vague preamble.

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 only two parameters, an output schema present, and a simple behavior, the description covers the action, prerequisite, and orientation nuance. Nothing needed for a correct call is missing; the schema covers bounds and enums.

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

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

Schema description coverage is 0%, and the description compensates meaningfully: direction is clarified as relative to the Agent's own facing rather than world coordinates, and times is given a concrete behavioral meaning with the times=2 turn-around example. The schema already supplies min/max/default, so the description adds the missing semantic layer.

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

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

The description names a specific verb and resource: '讓 Agent 原地左轉或右轉' (make the Agent turn left or right in place), specifies 90 degrees per turn, and thereby distinguishes itself from movement, placement, and collection siblings. The prerequisite and relative-direction note further sharpen what the tool does.

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 clearly states a condition of use: the Agent must first be summoned with mc_agent_create, and it notes the Agent is Education Edition exclusive. It does not explicitly contrast with mc_agent_move or other orientation-affecting tools, but the in-place rotation semantics make the appropriate use case evident.

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

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

The description goes well beyond the annotations by disclosing that the tool temporarily writes to the scratch region, backs it up before writing, restores it immediately after comparison, and aborts without modifying the world if backup fails. It also warns that overlapping scratch with the analysis region can destroy the original build and explains the underlying mirror-copy algorithm. This is excellent behavioral disclosure for a tool marked destructiveHint=true.

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 dense but efficient: it states purpose, method, safety behavior, and constraints in a few sentences. It is front-loaded with the primary function and then adds warnings. Slightly longer than strictly necessary, but every sentence carries useful information about behavior or limitations.

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

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

The description covers the tool's purpose, scoring semantics, algorithm, side effects, failure mode, safety restoration, overlap prohibition, and size limits. It also explains how asymmetric results are reported at a per-cell granularity. Combined with the output schema and annotations, nothing essential is missing for an agent to invoke this tool correctly.

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

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

Schema coverage is 100%, so the schema already documents all five parameters. The description adds practical semantic value by explaining the roles of the symmetry axes (x/z/xz), the meaning of cellsPerAxis as per-axis subdivisions, and the critical constraint that scratch cannot overlap the analysis region. This extra context helps the agent choose parameter values correctly.

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

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

The description states a specific verb ('檢查'), resource (a region/building), and the core function: detecting whether a region is mirror-symmetric and identifying which sub-blocks are not. It also distinguishes the output as a quantitative score (proportion of symmetric cells) rather than a heuristic judgment, clearly differentiating it from a generic region comparison like mc_compare_regions.

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 use case: grading student builds with an objective symmetry score. It also provides important operational conditions, such as scratch must not overlap the analysis region and region size limits. It does not explicitly name alternative tools or state when not to use it, but the use-case guidance is concrete enough for an agent to select it appropriately.

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?

Even though readOnlyHint=true already signals safety, the description adds genuinely useful behavior: the call blocks, it has a timeout, a timeout is not an error, and it reports connected=false. This is exactly the kind of behavioral context an agent needs and is not present in annotations.

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

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

Two short sentences deliver the core behavior, the timeout semantics, and the intended invocation context with no filler. The most important fact—blocking wait with a maximum duration—is front-loaded.

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

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

For a simple one-parameter tool with an output schema and read-only annotations, the description leaves no critical gap: it covers what the tool waits for, how long, how timeout is handled, and when to call it. The existing output schema supplies the return-structure detail that the description need not repeat.

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%, but the description names timeoutSeconds and explains that it is the maximum wait in seconds. It also clarifies the semantic consequence of reaching that timeout (connected=false), compensating for 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?

The description states a precise verb and resource: it blocks waiting for the game to connect to the bridge, with a timeout limit. This clearly distinguishes it from the sibling tools, none of which perform this bridge-connection wait. The added usage hint ('適合在請使用者輸入 /connect 之後呼叫') further anchors its 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 phrase '適合在請使用者輸入 /connect 之後呼叫' gives an explicit, actionable trigger for when to use this tool. It does not name alternatives or state when not to use it, so it stops short of a full when/when-not guide.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description reinforces this by saying it only calculates and does not start work. It adds useful behavioral detail about grouping blocks by type and reporting merged fill batch counts. No contradiction with the annotations.

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

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

The entire description is one sentence with no filler. It front-loads the critical non-action guarantee ('只計算不動工') before stating the computation and outputs, making it easy to scan.

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

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

Together with the read-only annotations, the rich input schema, and the output schema, the description provides enough context for correct invocation. A minor gap is that it does not specify how optional blockStates affect grouping or merged fill batch calculation, which could matter for blueprints that use block states.

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 for the top-level 'entries' parameter is 0%, but the description identifies it as a per-cell blueprint, adding domain meaning. The item-level schema already documents position, block, and blockStates, though the description does not clarify whether blockStates participate in grouping, so compensation for the missing top-level description is only partial.

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

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

The description states a precise computation ('only calculates, does not start work') on a specific resource (a cell-by-cell blueprint) and names the exact outputs: total block count and merged fill batch count. This clearly distinguishes it from actual building tools like mc_fill or mc_build_blueprint.

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 '只計算不動工' gives clear context that this is a planning-only tool and explicitly excludes performing construction. It does not name alternative sibling tools, but the boundary between calculating and building is clear enough for an agent to decide when 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?

Annotations already declare destructiveHint=true, idempotentHint=true, readOnlyHint=false. The description adds a non-obvious behavioral trait: identical blocks are automatically merged into the fewest possible fill commands, which affects execution cost and expectations. It does not contradict annotations. This extra context is valuable beyond the annotations.

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, front-loaded with the primary action and input format, and the sibling routing is placed second. No redundant phrasing; every clause earns its place.

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

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

Description plus schema and annotations cover what the tool does, when to use it, how input is structured, and the destructive/idempotent behavior. An output schema exists, so return values are accounted for. The only small gap is whether coordinates are absolute or relative, but Minecraft tool conventions and the plain integer schema make absolute coordinates the likely default, so this is not a serious omission.

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 by framing the sole parameter (entries) as a 'coordinate → block' list, which maps directly to the array of position/block pairs. It does not spell out the JSON structure or the optional blockStates, but the schema already provides those details, and the semantic framing is enough for an agent to form the correct input shape.

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 '蓋出任意形狀' (build any shape) with a specific verb and resource, and immediately clarifies the input mechanism (coordinate→block list). It explicitly contrasts with sibling mc_build_shape, which is for geometric shapes, and lists its intended use cases (pixel art, text, irregular shapes, external data), so an agent can distinguish it from alternatives.

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

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

Explicitly names the alternative tool mc_build_shape and gives a routing rule: prefer it for geometric shapes, use this for pixel art/text/irregular/external data. This is a clear when-to-use/alternative statement with no ambiguity.

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

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

Annotations already cover readOnlyHint=true and idempotentHint=true. The description adds specifics: it reports block count, bounding box, and fill command count, and emphasizes absolute world coordinates. This goes beyond the annotations without contradicting them.

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 purpose is front-loaded, the coordinate caveat and tool suggestion are concise, and no irrelevant detail is included.

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

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

For a preview tool with an output schema, the description adequately covers use, output highlights, and a coordinate prerequisite. It doesn't mention volume limits or edge cases, but those are likely in the output schema. It is sufficiently complete for an agent to call correctly.

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

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

Schema description coverage is 67% and the schema already documents shape variants and block states. The description adds no parameter-specific guidance (e.g., how to choose shape kind), so it stays at baseline without compensating for the uncovered parts of the schema.

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

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

The description opens with '只計算不動工' (only calculate, don't build), a specific verb+resource that immediately distinguishes it from building tools. It then lists concrete outputs: block count, bounding box, and number of fill commands. This clearly differentiates it from siblings like mc_build_shape and mc_blueprint_preview.

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 instructs to use mc_query_target when the player's location is unknown, and recommends using this preview tool before any build that changes the world. However, it doesn't explicitly name the building sibling (mc_build_shape) or state when NOT to use it, leaving some 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?

Annotations already declare destructiveHint=true, and the description reinforces this ('建造會直接改變世界'). It adds valuable behavioral traits beyond annotations: block coordinates are automatically merged into minimal fill commands (efficiency behavior), and coordinates are always absolute world coordinates. It also notes that most shapes support hollow. No contradictions found.

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

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

The description is well-structured and efficient: it starts with the core purpose, lists all shape kinds, mentions the hollow feature, explains the efficiency optimization, notes the coordinate system, and closes with usage guidance. Every sentence earns its place; there is no redundancy or filler.

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

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

Given the tool's complexity (12 shape variants) and the presence of an output schema, the description covers the key points: shape types, hollow capability, coordinate behavior, efficiency, and safety advice. It doesn't enumerate every parameter because the schema does that, but it provides the behavioral context an agent needs to invoke it correctly. The only minor gap is not referencing the blockStates parameter, but that is adequately documented in the schema.

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 itself provides rich description coverage (67%) with detailed descriptions for many shape-specific parameters (e.g., hollow, points, profile). The description adds the crucial note that coordinates are absolute world coordinates and that most shapes have a hollow option, which is not explicitly stated in the schema. The blockStates parameter is not mentioned in the description, but the schema covers it 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 clearly states the tool's purpose with a specific verb ('蓋出形狀' - build shapes) and enumerates all shape kinds (line, box, sphere, etc.), making it easy to distinguish from sibling tools like mc_fill or mc_set_block. It also mentions the hollow option and the coordinate merging optimization, which further clarifies 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 gives explicit usage guidance: it advises using mc_query_target if unsure of player location, and recommends using the corresponding preview tool before building to check block count and bounding box. It also warns that building directly modifies the world, implying when to exercise caution. No exclusions are needed since the shape-building purpose is clear, but the alternative tools are named.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, so the mutation profile is known. The description adds value by disclosing the specific destructive trait 'cloneMode="move" 會把原地清空' (move mode clears the source), which is exactly the what-gets-destroyed context annotations cannot express. It does not mention that normal cloning also overwrites destination blocks, but the destructive hint covers the general 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 with no filler: the operation, the key behavioral caveat, and the intended use case. The core purpose is front-loaded and 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?

The output schema and annotations cover return values and the safety profile, and the description covers the core flow plus the move-mode caveat. The main gap is that maskMode (a filter that meaningfully changes what gets copied) and the remaining cloneMode semantics are absent, so an agent invoking anything beyond defaults is left guessing.

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

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

With 0% schema description coverage, the description must compensate, and it partially does: it clarifies that begin–end defines the source region, destination is the copy target, and explains one cloneMode value ('move' clears the source). However, maskMode is never mentioned and the 'normal' and 'force' cloneMode values are left unexplained, leaving the compensation incomplete for a 5-parameter tool.

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

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

The description states a specific verb and resource: '把 begin–end 的區域複製到 destination' (copy the region from begin–end to destination), naming all three core parameters and their roles. The operation is unambiguous and clearly distinct from sibling tools such as mc_fill, mc_set_block, and mc_compare_regions, none of which copy a region.

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 final sentence '適合把手工蓋好的樣板量產' provides a concrete usage context: mass-producing hand-built templates. However, it names no alternative tools (e.g., mc_structure or mc_build_blueprint) and offers no when-not-to-use guidance, so it reaches clear context but stops short of 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?

The description adds valuable behavioral detail beyond the annotations: it explains the timeout avoidance for large regions, the nested semantics of masked mode (ignoring air in source), and the size-equality requirement. This contextualizes the read-only and idempotent nature without contradicting the annotations.

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 concise and well-structured: it front-loads the core purpose, then provides usage guidance, behavior specifics, and a key constraint. Every sentence contributes meaningful information without redundancy or fluff.

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

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

The description covers all essential operational aspects: what the tool does, when to use it, how masked mode alters behavior, the size requirement, and the meaning of destination. Since an output schema exists, return values do not need to be detailed here. The definition is complete for an agent to select and invoke the tool correctly.

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

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

With 100% schema description coverage, the baseline is 3, but the description enriches understanding of key parameters: it clarifies that masked=false requires exact equality, masked=true only checks for presence, and that destination is the minimum corner. It also adds the constraint that both regions must be the same size, which is not explicit in the schema.

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

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

The description clearly states the tool's function: comparing two equal-sized regions for consistency. It uses a specific verb and resource, and explicitly contrasts with per-block comparison, making its purpose unambiguous and distinct from siblings like mc_test_block or mc_analyze_symmetry.

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 for when to use this tool, such as checking student builds against a reference, and warns that per-block comparison times out for large regions. It implies the alternative is per-block checking but does not explicitly name a sibling tool, slightly reducing the guidance's precision.

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 all annotations false (no read-only, destructive, etc.), the description must carry the full behavioral burden. It mentions that 'clear' removes all effects, which is useful, but it does not disclose side effects like overwriting existing effects, persistence, or whether it modifies the world state. The coverage is minimal.

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

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

The description is a single, front-loaded sentence that quickly communicates the core behavior. It is concise without being verbose, but it is too sparse to be considered well-structured for a tool of this complexity. It omits necessary detail, so the brevity is a weakness rather than a strength.

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

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

For a 6-parameter tool with only 33% schema coverage, no annotations, and no provided output schema, this description is severely inadequate. It does not explain valid effect names, how duration and amplifier work, what 'clear' does exactly, or any constraints. An agent would have insufficient information to call the tool correctly, especially without schema documentation for most parameters.

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

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

Schema documentation covers only 'effect' and 'target' (33%). The description adds meaning for the 'action' parameter by explaining the semantics of 'apply' and 'clear', but it does not elaborate on 'seconds', 'amplifier', or 'hideParticles'. Given the low schema coverage, the description does not sufficiently 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 clearly states the tool applies or clears potion effects based on the 'action' parameter, identifying the exact operation and resource. It is specific enough to distinguish from generic siblings like mc_give or mc_summon, though it does not explicitly name an alternative.

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

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

No guidance is provided on when to use this tool versus alternatives. There are no exclusions, prerequisites, or context about when applying effects is preferable to other commands. The description only states what the tool does, not when to choose 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?

Beyond the annotations (readOnly, idempotent, non-destructive), the description adds meaningful behavioral detail: Mojang has not officially documented the list, out-of-list names are permitted, and those names are marked as unverified. It also states there are no side effects, which reinforces the safe-read nature of the 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 three short sentences with no filler: it states the purpose, discloses the unverified/official-documentation caveat, and confirms no side effects. Every sentence adds information an agent needs.

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

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

For a zero-parameter, read-only catalog tool with an existing output schema, the description is complete. It explains what is returned, the trustworthiness boundary of the list, and that calling it has no side effects. Nothing material 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, and the schema already covers this completely with an empty properties object. There are no parameter semantics for the description to add, so a baseline score of 4 is appropriate.

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

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

The description uses a specific verb ('回傳' / returns) and identifies the resource: known available event names for subscriptions. The title further clarifies it lists subscribable events, which distinguishes it clearly from siblings like mc_events_subscribe, mc_events_unsubscribe, and mc_events_poll.

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

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

The context is clear: an agent should call this tool to discover known event names before subscribing. It also cautions that the list is not officially documented and not exhaustive, implying it should not be treated as an authoritative closed set. It does not explicitly name alternatives, but the tool's catalog role is evident from its position among subscription-related siblings.

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

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

Beyond the readOnlyHint annotation, the description explains meaningful behavior: continuous reading via nextCursor, buffer wrap-around detection via dropped, and the implication that events may be permanently lost if dropped > 0. It also explicitly states '無副作用' (no side effects), which aligns with and reinforces the readOnlyHint annotation.

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 three concise sentences with no filler. It front-loads the core action, then provides the essential cursor usage, and ends with the important dropped warning. 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 polling tool with an output schema, the description provides enough context to use it correctly: initial cursor, continuation pattern, and failure signal. The remaining parameter details are present in the input schema, and the output schema covers return values. No critical operational context is missing.

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

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

The schema description coverage is only 33%, so the description must compensate. It does explain afterCursor semantics well, including the first-call value and nextCursor continuation. However, it does not describe the limit parameter, and eventName is already covered by the schema. This is adequate but leaves one parameter's semantics to the schema's default and range constraints.

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

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

The description clearly states the tool's function: '取出游標之後的事件' (retrieve events after a cursor). It uses a specific verb and resource and is distinct from sibling tools like mc_events_catalog, mc_events_subscribe, and mc_events_unsubscribe by focusing on polling/reading already-received events.

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 concrete usage instructions: use afterCursor=0 for the first call and pass the returned nextCursor thereafter. It also explains how to interpret the dropped indicator. It does not explicitly mention when to prefer this over sibling tools, but the cursor-based polling pattern is clearly conveyed.

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

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

The description adds meaningful behavior beyond the annotations: events are stored in a ring buffer, consumed via mc_events_poll, and subscriptions are automatically re-established after reconnection. This complements the idempotentHint annotation without contradicting it.

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

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

Three concise sentences cover the purpose, behavior, follow-up operation, and reconnection semantics without redundancy. The most important information is front-loaded with clear examples.

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 subscription tool with an output schema and annotations, the description covers the key aspects: what to pass, what happens to events, how they are retrieved, and reconnection behavior. It does not mention the event catalog, but sibling naming makes that discoverable.

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

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

The input schema provides no description for eventName and schema description coverage is 0%. The description partially compensates by giving examples of valid event types, but it does not specify where to find the complete list of event names or whether the value must match an exact catalog entry.

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

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

The description states a specific action (開始接收 / subscribe) targeting a specific resource (某類遊戲事件), with concrete examples like PlayerMessage, BlockPlaced, and PlayerTravelled. It clearly distinguishes this tool from the sibling poll tool by explaining the ring-buffer flow.

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 usage context: subscribe first, then retrieve events with mc_events_poll. It explains the purpose as letting the AI perceive player actions. It does not explicitly mention alternatives like mc_events_catalog or mc_events_unsubscribe, but the flow with mc_events_poll is explicit enough.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false; the description adds meaningful context that already-buffered events are not cleared, which goes beyond the structured hints. No contradiction with annotations.

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

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

Two short sentences, front-loaded with the primary behavior and a compact clarification about buffered events. 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 one-parameter tool with an output schema and idempotency annotation, the description covers the essential behavior and buffer caveat. The main gap is not referencing the event catalog or subscribe counterpart for valid eventName values.

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

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

Schema description coverage is 0% and the sole parameter eventName is only documented as a string. The description says '某類事件' (a certain type) but does not explain valid event names or point to mc_events_catalog for the list, leaving the agent to guess.

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

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

The description states a specific action ('stop receiving a certain type of event') with a clear resource (game events), and the verb 'unsubscribe' distinguishes it from poll/subscribe/catalog siblings.

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

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

The use case is implied by '停止接收' (stop receiving), but the description does not explicitly say 'use after mc_events_subscribe' or 'do not use to clear the buffer.' It lacks explicit when-to-use 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?

The annotations are all false and provide no helpful hints, so the description carries the behavioral disclosure burden. It only states that sounds are played and particles are generated; it does not disclose scope of listeners, whether effects are transient, stacking behavior, or any side effects. It does not contradict the annotations, but adds little beyond the title.

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

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

The description is a single short sentence that front-loads the core action and purpose. There is no filler or unnecessary repetition of schema 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?

The tool has four parameters, an output schema, and a large sibling set, yet the description is minimal. It is enough to understand what the tool does, but it lacks guidance on selecting it over similar tools and does not compensate for the sparse behavioral and parameter context.

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

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

Schema description coverage is about 50%, with id and target described but kind and position lacking top-level description. The description adds a useful semantic hint by associating coordinates with particle generation and sound with being played, but it does not explain the id format, the meaning of kind, or how target works.

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 resource and action: play a sound effect or generate a particle effect at coordinates, with the stated purpose of immediate sensory feedback. It does not explicitly contrast with sibling tools, but the sound/particle focus makes the tool's role reasonably 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?

The phrase '用來給玩家即時的感官回饋' gives an implied use case: use this when the agent wants to provide quick in-world feedback. However, it does not say when not to use it, nor does it point to alternatives such as mc_message, mc_effect, or mc_run_command that could serve similar purposes.

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

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

Annotations already include `destructiveHint=true` and `idempotentHint=true`. The description goes beyond those by specifying the Bedrock per-operation limit of 32768 blocks and the meanings of `mode=hollow` (only outer shell) and `mode=outline` (only border), which are not in the annotations. This adds valuable context, though it does not elaborate on other mode effects like `replace` or `destroy`.

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 purpose and immediately followed by the key usage constraint and mode clarifications. There is no filler or redundant repetition of schema or annotation content.

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 that an output schema exists and annotations cover destructive and idempotent behavior, the description adds the most critical operational detail: the block count limit and the alternative tool for exceeding it, plus the hollow/outline mode semantics. It does not explain the full set of mode values (e.g., replace/destroy/keep), but those are standard Minecraft commands and partly described in the schema.

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 around 57%. The description compensates for the `mode` parameter by explaining the hollow and outline options, and it clarifies that the `block` parameter applies the same block across the whole volume. However, it does not add detail for coordinate modes or the replace-related parameters, leaving some meaning to the schema descriptions.

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

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

The description states a specific verb (fill) and resource (a cuboid from `from` to `to`) and clarifies that it uses a single block type. It also distinguishes itself from the sibling `mc_build_shape` by calling out the size threshold, which helps an agent separate the two tools.

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

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

The description explicitly says that when the fill exceeds 32768 blocks, the agent should use `mc_build_shape` instead, which automatically batches. This is a clear when-not/alternative rule, and it implies that `mc_fill` is appropriate for fills within the limit.

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

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

Annotations 已標示 readOnlyHint=false，描述「切換」也與此一致，但描述沒有額外揭露行為特質，例如改動目標遊戲模式後對遊戲的影響、是否需要權限、是否會覆寫既有模式等。idempotentHint=true 和 destructiveHint=false 的含義也未在描述中補充。

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?

一句話即完整表達核心操作與可選模式，沒有冗詞，資訊密度高且直接切入重點。

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?

此工具雖簡單，但考量到兄弟工具眾多且包含 mc_run_command 這種可能替代的通用指令工具，描述未提供任何使用情境或排除條件；同時也未說明切換遊戲模式的實際行為後果。搭配 annotation 與 output schema 仍不足以讓代理判斷何時該選此工具。

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 對 target 有提供詳細說明，但 mode 參數只有 enum 沒有 prose 描述；描述中的「survival、creative、adventure 或 spectator」補足了 mode 的語意，且「對象」也暗示了 target 的用途。不過描述並未說明 mode 為必要參數或 target 預設為 @s，因此只算部分補償。

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?

描述明確指出要對目標執行「切換遊戲模式」的動作，並列舉 survival、creative、adventure、spectator 四種模式，語意清楚且涵蓋資源與操作。但未特別與其他兄弟工具（如 mc_player_action 或 mc_run_command）做區隔，因此不到 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?

描述完全沒有提到何時應使用此工具、何時不應使用，也沒有指出與 mc_run_command、mc_player_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?

Annotations are all false and offer no safety or side-effect information. The description only states the action without disclosing any behavioral nuances, such as impacts on existing inventory, permission requirements, or error handling. For a mutation tool, this is a significant gap.

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

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

The description is two sentences long, front-loads the main action, and the second sentence adds valuable workflow context without any fluff. 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 simple give tool, the description plus schema is mostly adequate. The workflow hint is useful, and the output schema covers return values, but there is no mention of edge cases (e.g., max stack size, inventory overflow) or cautions when giving items to players vs. agents.

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%, covering item and target, but data and amount lack schema descriptions. The tool description does not compensate for this, explaining none of the parameters or any additional meaning like data values or stacking behavior.

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

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

The description states a specific verb (give), resource (items), and target (object), making the core action clear. However, it does not explicitly differentiate this tool from siblings like mc_run_command, which could also give items via a command.

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 second sentence provides a concrete workflow: to give items to an Agent for placing, first give to the player and then to the Agent. This gives clear context for one use case, though it does not mention alternative tools or exclusions.

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

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

The description discloses meaningful behavioral detail beyond the annotations: say broadcasts to global chat, tell sends a private message, and title/subtitle/actionbar display large on-screen text. It makes the observable effect of each channel transparent without contradicting the annotations.

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

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

The description is a single well-structured sentence that front-loads the tool's purpose and channel breakdown without any filler. Every part adds meaning, and the format is easy to parse quickly.

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

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

For a simple messaging tool, the description covers the essential behavior and usage context, and an output schema is available for return-value details. It is not fully complete because target and message semantics are under-described, but the overall complexity is low and the main decision points are addressed.

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 33%, so the description should compensate for the undocumented 'message' parameter and clarify the 'target' parameter. It adds useful semantics for the 'channel' enum, but says nothing about what message content should look like or how target selectors/player names operate beyond the schema's terse description.

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

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

The description clearly states that this tool sends messages to players and enumerates the exact channels (say, tell, title, subtitle, actionbar) with their distinct behaviors. It is unmistakably differentiated from sibling tools that perform actions, block edits, or queries.

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

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

The description gives a concrete usage context: '教學或回報進度時用這個跟玩家說話' (use this to talk to players when teaching or reporting progress). It does not explicitly state when not to use it or name alternative tools, but the context is clear enough for an agent to know when this tool is appropriate.

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

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

Annotations declare destructiveHint=true and readOnly=false, which already signal mutating behavior. The description adds per-action details such as clear being able to target a single item and ability toggling permission flags. However, it does not disclose side effects like the irreversibility of kill, the ability to use negative xp amounts, or whether ability changes persist.

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 dense sentence that front-loads all four action types and their effects. There is no filler or redundant repetition of the schema. Each segment 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 7 parameters and 4 distinct behaviors, the description is terse. It covers the main action meanings but omits important operational details such as how unit affects xp, what enabled controls, and interaction with target selectors. The schema covers target and amount, and an output schema exists, but the combination is still not fully self-sufficient for an agent to use all options correctly.

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

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

Schema description coverage is only 43%, so the description must compensate. It does clarify the action enum and the meaning of the item parameter for clear. However, it leaves unit (levels vs points), enabled (boolean), and ability parameter semantics unstated, requiring the agent to guess from enum names or default values.

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

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

The description clearly enumerates the four actions (kill, clear, xp, ability) and states what each does: killing a target, clearing inventory optionally for a single item, granting experience, and toggling permissions. This gives a specific verb and resource scope. It does not explicitly distinguish itself from sibling tools like mc_give or mc_effect, but the action list makes the tool's purpose immediately understandable.

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

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

The description provides no guidance on when to use this tool versus alternatives such as mc_give, mc_effect, mc_gamemode, or mc_run_command. There are no exclusions, prerequisites, or routing hints. The agent must infer usage from action names alone.

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

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

Annotations already establish readOnly, idempotent, and non-destructive behavior. The description adds meaningful behavioral context beyond that: output is resolved JSON, default target is @p rather than @s, and @s can fail in some WebSocket cases because the command has no entity identity. No contradictions.

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-load the purpose and output, then the use case, then the default caveat. Every sentence adds essential information with no padding.

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 one optional parameter, full schema coverage, an output schema, and annotations already covering safety, the description covers everything needed to invoke correctly: what it returns, when to call it, and the selector default caveat.

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 already documents the target parameter with 100% coverage, so the baseline is 3. The description adds value by explaining the practical semantics of the default: why @p is preferred and why @s is unreliable in this context, which helps an agent choose or accept the value correctly.

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 (查詢/query) with a specific resource (實體 entities) and names the exact outputs: coordinates, orientation, and unique ID, returned as resolved JSON. It also labels itself as the canonical way to get a player or Agent's current position, which separates it from the broader sibling set.

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 clear context: call this before building to know where to place things, and it is the standard way to get player/Agent positions. It explicitly warns about the @s selector failing over WebSocket and explains the default @p choice, though it does not name an alternative tool or specify when NOT to use this 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?

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint: false), so the description earns credit for enriching behavior beyond them: it discloses the implementation quirk (testforblock workaround because Education lacks a read command), the localized-name return semantics, and the failure contract (returns null plus raw message rather than guessing). It also warns that the message format is not officially guaranteed, which is exactly the kind of non-obvious behavior an agent needs.

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

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

Four sentences, purpose front-loaded, and every sentence carries load: the core function, the implementation rationale, the return-type caveat plus sibling routing, and the failure/parsing behavior. It is on the longer side, but the length is justified because the tool's testforblock hack and unguaranteed message format are genuinely non-obvious and risk-mitigating for an agent.

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 an output schema, full safety annotations, and a clear single positional parameter, the description covers everything essential: purpose, alternative tool, output semantics caveat, and failure handling. Minor gaps remain — no mention of world-boundary/loaded-area constraints or permission requirements — but nothing an agent needs to invoke the tool 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 description coverage is reported at 0%, so the description carries the burden of parameter explanation, yet it says nothing about how to specify position, coordinate modes, or format. The gap is mitigated by the parameter being a self-evident coordinate triple and the schema's inline mode enum description (absolute/relative/local), making the missing compensation a moderate rather than severe deficiency.

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-resource pairing ('回報該座標實際上放著什麼' — reports what is actually at that coordinate) and immediately differentiates itself from siblings by warning that it returns localized display names, not block IDs, and explicitly routing ID-based checks to mc_test_block. The mechanism (air sentinel feeding testforblock) further clarifies what the tool is and is not.

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 explicit when-to-use context ('不需要你先猜' — use this when you need ground truth rather than assumptions) and an explicit when-not-to-use rule with a named alternative ('要用 ID 判斷請改用 mc_test_block'). It also states a concrete downstream constraint: the localized-name output cannot be fed back into mc_set_block.

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

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

Annotations already mark destructiveHint=true, and the description adds important caveats: single-line only, no newline chaining, and rejection of bridge-breaking commands. This goes beyond the schema and gives the agent critical context about safe invocation.

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 with no redundancy. The core purpose, constraints, and exclusions are all front-loaded, making the description easy to parse quickly.

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

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

For a simple one-parameter tool with a full output schema and annotations covering destructive behavior, the description supplies all necessary behavioral constraints and usage boundaries. Nothing critical 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 schema covers the single 'command' parameter 100% with an example. The description does not add parameter-specific details beyond the overall command-sending context, so the baseline of 3 applies.

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

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

The description clearly states the tool sends a raw slash command and explicitly scopes it to functionality without a dedicated tool, which distinguishes it from the many specialized sibling tools. The verb 'send' and resource 'slash command' are specific and unambiguous.

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

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

It tells the agent to use this when no dedicated tool exists, and explicitly forbids wsserver/connect commands that would sever the bridge. It does not name sibling alternatives like mc_run_commands, but the 'no dedicated tool' condition provides clear selection guidance.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, but the description adds useful behavioral context: commands are raw, sent in order, and each one independently passes policy checks. This goes beyond the structured annotations and helps the agent understand execution semantics and safety implications.

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 no waste: the first states the core behavior, the second gives usage guidance and alternatives. The most important information is front-loaded and every clause earns its place.

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

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

The description covers purpose, usage boundaries, and some behavioral nuance, and an output schema exists so return values need no explanation. However, it omits key parameter semantics, especially stopOnError and delayMs, which are relevant for a command runner and are not documented anywhere else. The presence of annotations and schema constraints mitigates this, so it is adequate but not complete.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining parameters, but it only vaguely hints at the commands array via 'multiple raw commands'. It does not explain delayMs or stopOnError, leaving the agent to rely solely on parameter names, defaults, and constraints in the schema.

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

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

The description clearly states the tool's function: sending multiple raw commands sequentially, each passing policy checks. It differentiates itself from related siblings by explicitly naming mc_build_shape and mc_build_blueprint as alternatives for bulk block operations and by the 'multiple commands' framing, distinguishing it from the singular mc_run_command.

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 this is suitable for manually orchestrated macros, and provides a clear exclusion: for large numbers of blocks, use mc_build_shape or mc_build_blueprint instead. This gives the agent concrete decision criteria between this tool and its main 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?

The annotations already disclose destructive and idempotent behavior, and the description adds a useful performance warning beyond them. However, it does not explain the default replace/destroy/keep handling behavior or what happens to existing blocks at the target position, so behavioral transparency is adequate but not rich.

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

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

One focused sentence front-loads the core action and then gives the scale-based alternative. Every part earns its place and there is no redundant wording.

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-block mutation tool, the description plus annotations and output schema cover the essential selection and invocation context. It could add handling semantics, but the missing details are partially available in the schema and annotations, so the overall picture is nearly 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?

With only 50% schema description coverage, the description needed to compensate for undocumented parameters such as handling, but it merely restates 'specified coordinates' and 'one block'. It adds no explanation of handling, position modes, or block-state syntax beyond what the schema already 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?

The description uses a specific verb and resource ('place one block at specified coordinates') and explicitly differentiates itself from mc_fill and mc_build_shape for large numbers of blocks. This lets an agent distinguish it from relevant sibling tools immediately.

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 an explicit when-to-use rule: use for a single block, and switch to mc_fill or mc_build_shape for large quantities because per-block calls are slow. This is direct, actionable guidance with named 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description reinforces this with '無副作用' and adds useful behavioral context by specifying what status information is reported. No contradictions exist.

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 dense sentence that front-loads the main reporting items and ends with a usage guideline. Every element earns its place, and there is no fluff 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 0-parameter status tool with an output schema and comprehensive annotations, the description provides enough context: what it reports, when to use it, and that it has no side effects. It doesn't explain the output structure, but that's covered by the output schema.

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

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

The tool has zero parameters and the schema is empty, so the baseline is 4. The description correctly omits any parameter details as none exist; there is nothing missing.

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

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

The description clearly states the tool's function with a specific verb '回報' and lists the exact status items it reports: WebSocket bridge listening state, Minecraft connection, /connect command, subscribed events, and cumulative command count. This distinguishes it from sibling tools like mc_await_connection or mc_feedback.

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 instructs to check this tool first when any tool fails ('任何工具失敗時先查這個'), providing a clear when-to-use context. It doesn't name alternative tools, but the condition is actionable and sufficient for 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?

Beyond the destructiveHint annotation, the description discloses that disk mode writes actual files to the game world folder on the user's hard drive, persists after closing the game, and should not be used without explicit user request. It also explains that memory mode disappears on shutdown and that same-name saves overwrite silently. These are exactly the behavioral traits an agent needs to avoid destructive mistakes.

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 longer than average but every section earns its place: purpose, mode selection, persistence consequences, and versioning rules. The formatting with bolded headers and bullet-like lines makes it easy to scan, and the most safety-critical warning about disk writes is prominently placed.

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 an output schema present and input schema descriptions covering coordinate modes and required parameters, the description covers most operational context: when to use memory vs disk, how versioning works, and what happens on overwrite. The main gap is includeEntities, which has a default but no guidance on when an agent should enable it. Overall it is nearly complete for a destructive-capable tool.

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

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

The description adds significant meaning to saveMode and name that the schema only gestures at: memory vs disk semantics, user-intent-based selection, and versioning via names. It also communicates the action-dependent coordinate roles indirectly. However, includeEntities is left undocumented in both the schema and the description, and parameter coverage is only 71%, so the description does not fully close the gap.

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

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

The description clearly states a specific verb and resource: saving a region as a named structure or loading it back into the world, and positions it as the official path for preserving, mass-producing, and transporting AI-built structures. It does not explicitly differentiate from siblings like mc_clone or mc_blueprint_preview, so it lacks explicit sibling contrast, but the core 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 gives strong, decision-oriented guidance for saveMode: memory for session-scoped iteration and disk only when the user explicitly asks for persistence. It also warns about same-name overwrites and points to mc_status for listing session saves. It does not explicitly discuss when to use this tool versus alternatives such as mc_clone, but it provides clear context and practical constraints.

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 behavioral annotations, the description carries the transparency burden. It does disclose the core effect (spawning an entity) and the position/name-tag defaults, but it does not mention permissions, duplicate-entity behavior, or any broader world-modifying side effects, leaving some behavioral gaps.

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

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

One compact sentence front-loads the main action, then covers the two optional behaviors. No filler or repetition.

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

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

For a 3-parameter tool with an output schema and detailed entity/coordinate-mode info already in the schema, the description covers the essential defaults and optional name tag. The only missing context is permission-level or operational caveats, which are not critical for basic invocation.

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

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

Schema coverage is only 33%, so the description must compensate. It does: it clarifies position defaults to the caller when omitted and that nameTag is optional. The schema still handles the entity ID example and coordinate mode, so the description adds meaningful value without duplicating the schema.

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

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

The description uses a specific verb and resource: '在指定座標生成一個實體' (spawn an entity at specified coordinates), and adds the optional name tag. This clearly separates it from sibling tools like mc_set_block (blocks) and mc_give (items), so an agent can select it without opening the schema.

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

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

It gives one useful invocation rule: leaving position empty spawns at the command issuer's location. However, it never states when to prefer this tool over alternatives or when not to use it, so the usage guidance is mostly implied by the tool's purpose.

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

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

Annotations already classify this as non-read-only, idempotent, and non-destructive, and the description is consistent with that. It adds no extra disclosure about permissions, chunk-loading, or failure modes, but the annotations lower the burden.

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

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

Two short sentences with the action front-loaded and no filler. Slightly under-specified for the nested destination/mode structure, so not a perfect 5.

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 teleport tool with an output schema and annotations covering safety/idempotency, the core invocation is understandable. The main gap is lack of routing guidance among teleport-related siblings, and coordinate mode semantics depend entirely on the schema.

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

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

The description adds the useful note that target defaults to the executing player and frames the target as a selector, but it largely repeats schema info. With 50% schema coverage, x/y/z are left to inference, though the mode enum in the schema covers coordinate semantics.

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

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

The description states a concrete verb (傳送) and resource (selector-specified targets to coordinates), and the title narrows it to players/entities. It is clear, though it does not explicitly contrast itself with mc_agent_teleport.

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

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

It provides no guidance on when to use this tool instead of alternatives such as mc_agent_teleport or mc_agent_move, and no exclusions. The only usage hint is the @s default, which is more parameter-oriented than selection guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that the tool 'only reports whether the coordinate is the specified block', clarifying the return semantics as a boolean, and reiterates 'does not change the world' which aligns with annotations. It does not disclose other behaviors like error handling, but the safety profile is fully covered by annotations.

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 consists of two concise sentences, front-loading the core behavior ('does not change the world, only reports whether the coordinate is the specified block') followed by usage context. Every word serves a purpose with no redundancy.

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

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

For a simple, read-only test tool, the description covers purpose, usage, and non-destructiveness. Required parameters are documented in the schema (with most having descriptions), annotations cover safety, and an output schema exists, so no return value explanation is needed. All necessary contextual information is present.

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

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

The description does not explain any parameters, merely referring to 'that coordinate'. The schema provides helpful descriptions for block, blockStates, and the mode field, but the position object itself lacks a description. With schema description coverage at 67% (not high), the tool description was expected to compensate for missing parameter guidance but does not.

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

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

The description clearly states the tool's function: it does not change the world and reports whether a coordinate is the specified block. It also provides concrete use cases (confirming terrain before building, verifying recent builds), which distinguishes it from siblings like mc_read_block that likely return block data rather than a boolean test.

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 explicit usage context: use this tool before construction to check terrain or to verify placed blocks. However, it does not explicitly mention when not to use it or name alternative tools, so it lacks exclusions but still provides clear 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?

Annotations indicate a non-read-only, non-destructive, idempotent mutation, but do not explain the persistent world behavior. The description adds that the area remains loaded and its mechanisms continue functioning after player departure, which is meaningful context beyond the annotations.

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

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

Two short sentences front-load the core action and effect, then add the key use case. Every sentence earns its place with no redundant detail.

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

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

The description gives the purpose and effect but omits parameter semantics and any prerequisites or limitations (e.g., area limits, persistence behavior once unloaded). The output schema exists and annotations help, so the gaps are moderate; an agent could probably call it correctly by using the schema structure, but not from the description alone.

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