baton

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

No annotations provided, so description carries full burden. It states '조회한다' (queries), indicating non-destructive behavior, and explains fallback to Free plan. Missing details on authentication requirements beyond api_key, potential rate limits, or side effects.

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

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

Two sentences, zero wasted words. The main purpose is front-loaded in the first sentence, and the second sentence provides essential default behavior.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description sufficiently covers what it does and the input default. It could mention that it is read-only, but the verb '조회' implies that. The sibling list shows distinct tools, making context adequate.

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

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

Schema covers the only parameter with 100% description coverage. The description adds value by explaining default behavior when api_key is missing ('Free 기준'), which the schema does not convey.

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

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

Description clearly states it queries plan, limits, and usage. The verb '조회한다' specifies a read operation on account info. It distinguishes from sibling tools like 'baton_create_room' which are action-oriented, but does not explicitly differentiate among similar 'baton_*' 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?

Implies usage: can be used without api_key to see Free defaults. However, no explicit guidance on when to choose this over siblings like 'baton_verify_plan' or 'spider_plan', nor when not to use it.

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

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

No annotations are provided, and the description does not disclose behavioral traits beyond the basic action. It does not mention side effects, authentication requirements, or whether the action is reversible. The parameter api_key hints at authentication but is not explained in 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 single, efficient sentence with no redundancy. It is front-loaded and to the point.

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

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

Given no output schema and no annotations, the description should provide more context for correct invocation. It lacks information about prerequisites (host role, room state), return values, and error conditions. Incomplete for a tool with three required 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 description coverage is 67% (two of three parameters have descriptions). The tool description does not add additional meaning beyond the schema. Baseline 3 is appropriate as the description adds no extra parameter context.

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 the tool approves a waiting person by the host, specifically for rooms requiring approval. This verb+resource structure distinguishes it from sibling tools like baton_kick (remove) or baton_join (join).

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

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

No guidance on when to use this tool versus alternatives. It does not specify that the caller must be the host or that the room must be in require_approval mode. No explicit when-not or alternative references.

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

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

The description explicitly discloses the destructive behavior: the room, invitation code, and messages are all destroyed. This adds value beyond the bare action name. However, it does not mention irreversibility or required permissions beyond the implied host role.

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

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

The description is a single sentence that immediately conveys the core purpose and consequences. No wasted words.

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

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

For a simple destructive action with two parameters, the description covers the key behavioral aspects. However, the lack of output schema and parameter details slightly reduces completeness.

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

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

Schema description coverage is 50% (only api_key has a description). The tool description does not add any parameter-specific details beyond what is in the schema. The meaning of room_id remains underspecified.

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

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

The description clearly states the tool's action (closes room) and its effects (destroys room, invite code, messages). It is specific about the scope. However, it does not explicitly distinguish from sibling tools like baton_leave or baton_kick.

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 explicit guidance on when to use this tool versus alternatives. It does not state prerequisites like being the host or the irreversible nature. The usage context is only implied by the description.

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

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

No annotations provided, so description carries full burden. It discloses that the tool performs an upgrade upon verification (write operation), but does not detail side effects, failure behavior, or permission requirements. Basic transparency is present.

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: first states purpose, second lists inputs and condition. No unnecessary words. Front-loaded with key action. Highly efficient.

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

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

Given 5 required params, no output schema, and no annotations, description covers core functionality and input constraints but lacks details on return values, error cases, or post-verification behavior. Adequate but incomplete for complex usage.

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 description must compensate. It lists required fields (invoice_id, token, chain, api_key, tx_hash) and specifies token/chain enums. However, it does not explain each parameter's purpose beyond names. Adds some value but not comprehensive.

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?

Description clearly states the tool verifies a sent transaction hash on-chain to upgrade the plan. This distinguishes it from siblings like baton_upgrade (which may perform the upgrade directly) and baton_verify (generic verification). The verb 'confirm payment' and resource 'payment' are specific.

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?

Description implies usage after sending a payment transaction, but does not explicitly state when to use vs alternatives. It gives a condition (correct token/network combination), but no when-not or alternative tools are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It reveals the consolidation process and output content (verification tier, verifier), but does not mention side effects, reversibility, or whether original handoffs are modified.

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?

Description is concise and front-loaded with the main purpose. Every sentence adds value, though written in Korean which may require translation for non-Korean agents.

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

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

Given no output schema or annotations, the description adequately covers purpose, two usage modes, and what the board displays. It is sufficient for an agent to decide to invoke, though lacks details on return format or error handling.

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?

While the input schema already describes each parameter (coverage 100%), the description adds value by explaining the two workflows that connect parameters: direct codes submission vs. automatic room consolidation with api_key, clarifying how to choose between them.

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 the tool consolidates multiple handoffs into one result board, displaying verification tier and verifier. It distinguishes itself from sibling tools like baton_send or baton_receive by focusing on consolidation.

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?

Provides clear context on two usage modes: direct input via codes[] or automatic room consolidation with room_id+api_key. However, it does not explicitly state when not to use or mention 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?

Discloses key behaviors: invite_code expiry (72h), auto-entry via alias, require_approval mode, and api_key purpose (management + auto-attachment). No annotations exist, so description carries full burden well.

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

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

Two concise sentences; front-loaded with purpose, followed by key details. No 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?

Covers all aspects: creation, return values, parameter behaviors, constraints. No output schema but return values explained. Complete for a creation 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?

Adds value beyond schema: explains alias triggers auto-entry, require_approval controls entry, api_key is for management and auto-attached. Schema coverage is 100% but description enriches understanding.

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 creates a persistent team room and specifies return values (room_id, invite_code). It distinguishes from sibling tools like baton_join or baton_close_room, which handle different operations.

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

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

Implies usage for room creation but does not explicitly mention when not to use it or alternatives. Context signals like sibling tool names provide implicit differentiation.

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

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

No annotations are provided, so the description bears the full burden. It states the tool returns changes, implying a read-only operation, but does not explicitly confirm no modifications, no side effects, or any permissions required.

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

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

The description is concise with two sentences: first stating purpose and scope, second giving a concrete usage example. No redundant information, though the language may not be English.

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 2 parameters, no output schema, and no annotations, the description explains the core functionality but is vague on return format and parameter details. More specificity would improve completeness.

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

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

Schema description coverage is 0%, and the description only provides an example (yesterday vs today) without defining the parameters 'from_code' and 'to_code' explicitly. It adds context but not full 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 tool compares two handoff snapshots and returns changes (additions/deletions of goal, status, decision, next task, warning). This specific verb+resource combination distinguishes it from sibling tools.

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

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

The description implicitly suggests usage by example ('check difference between yesterday's and today's handoff'), but does not explicitly state when to use or not use alternatives. No guidance on prerequisites or exclusions.

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

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

Without annotations, the description discloses a critical behavioral trait: received content is wrapped as 'untrusted data' and instructions should not be executed. This addresses a key safety concern, though it lacks details on authentication or rate limits.

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

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

The description is concise (two sentences) and front-loaded with purpose. However, it could be more structured to include parameter information without increasing length significantly.

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 important behavioral aspect but lacks parameter details and return value explanation (no output schema). It is adequate for a simple tool but incomplete for effective use.

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 the parameters ('since' and 'member_id') at all. With only 50% schema coverage, the description should compensate but fails to add any semantic value.

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

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

The description clearly states the action ('Check my inbox') and the resource ('inbox'), and distinguishes itself from siblings like baton_send and baton_receive by noting the untrusted data wrapping and instruction handling.

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

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

Usage is implied (checking inbox), but there is no explicit guidance on when to use this tool versus alternatives like baton_receive or other baton tools, nor any 'when not to use' conditions.

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

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

Discloses that the tool returns a member_id and the code is a one-time ticket. However, without annotations, it omits side effects (e.g., adds user to room), permission requirements, or error behaviors.

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

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

Two concise sentences, front-loaded with key action, no wasted words. Efficient for an AI 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?

Explains return value usage, compensating for lack of output schema. Could mention error handling for invalid codes, but overall adequate for a simple join action.

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

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

Schema already describes all parameters (code, alias, model) with 100% coverage. Description adds context about using the return value, but does not deepen parameter meaning beyond 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?

Description clearly states the tool enters a room using an invitation code and registers a nickname. It specifies that the returned member_id is used for send/inbox, distinguishing it from siblings like create_room or leave.

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?

Implies usage context by mentioning member_id for send/inbox, but does not explicitly state when to use this tool versus alternatives like baton_create_room or baton_pass. No when-not or exclusion criteria.

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

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

No annotations provided, so the description must disclose behavior. It only states the basic action without mentioning side effects, permissions, rate limits, or reversibility. For a mutating tool, this is insufficient.

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 extremely concise (one sentence). It is front-loaded and contains no wasted words, but could benefit from additional context without becoming verbose.

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

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

For a simple tool with 3 required parameters, the description does not explain parameter usage, output, or what happens after the kick. It is incomplete for an AI agent to use without additional inference.

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 low (33%), with only one parameter (api_key) described. The description adds no further meaning to the parameters, leaving room_id and target_member_id undefined.

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

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

The description clearly states the action ('kicks out') and the specific resource ('a participant'), performed by the host. This distinguishes it from sibling tools like baton_leave (self-leave) and baton_join.

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

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

No guidance on when to use this tool versus alternatives (e.g., banning vs. kicking). No prerequisites or conditions mentioned (e.g., must be host, target must be in room).

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?

Minimal behavioral disclosure. Does not explain side effects (e.g., removed from room), permissions required, or whether it applies to the caller or another member. No annotations provided.

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 extremely concise but at the expense of clarity and completeness. It lacks structure and provides no useful details beyond the name.

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

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

Given a single-parameter tool, the description fails to provide essential context about return values, prerequisites, or behavior. Incomplete for reliable agent usage.

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 required parameter 'member_id' has no description in schema (0% coverage) and is not explained in the tool description. The agent cannot infer its meaning or format.

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 'Leave the room' conveys the basic action but lacks clarity on context (which room, leaving for which member) and does not distinguish from sibling tools like baton_join or baton_kick. The Korean language may also cause confusion.

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

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

No guidance on when to use this tool versus alternatives. Sibling tools like baton_join, baton_kick exist but no criteria for choosing baton_leave.

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

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

With no annotations provided, the description bears full responsibility for behavioral disclosure. It mentions the 72-hour validity and the effect of revoke_old=true, but it does not disclose error behaviors, authentication requirements beyond api_key, or rate limiting. It covers key side effects but lacks depth.

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 that immediately convey the main action and a key parameter's effect. Every sentence adds value without redundant 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 the tool has three parameters, no output schema, and no annotations, the description should provide more context about return values, error conditions, and required permissions. It lacks information on what the tool returns (e.g., the new invite code) and does not address failure scenarios.

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 low at 33%, and the description adds meaning for revoke_old by explaining its effect. However, it does not explain the room_id parameter, and the api_key description in schema is simple. The description partially compensates for the coverage gap but not fully.

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

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

The description clearly states the tool's purpose: '방장이 새 초대코드를 발급한다(72h)' (host issues a new invitation code with 72h validity). It also describes the effect of the revoke_old parameter. The tool is distinguishable from siblings like baton_revoke (which revokes codes) and baton_join (which uses codes) as it creates new invite codes.

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

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

The description does not provide explicit guidance on when to use this tool over alternatives. It lacks statements like 'Use this to generate a new invite code; use baton_revoke to invalidate existing codes.' The usage context is implied but not directly compared to siblings.

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

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

With no annotations, the description must cover behavioral traits. It discloses that the body is encrypted with a code-derived key (server cannot see plaintext), secrets are automatically masked, and providing e2e_evidence triggers an immediate signed receipt. This adds significant transparency beyond the input schema.

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

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

Two concise sentences front-load the primary purpose and then add key behavioral details. Every sentence serves a clear function with no fluff. Well-structured for quick understanding.

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

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

Given complexity (9 params, nested objects, no output schema), the description provides essential functional context: what it does, encryption, and verification integration. However, it lacks details on return structure (the handoff code format is mentioned but not full response) and error scenarios. It does not cover prerequisites like api_key availability.

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 high (89%), so baseline is 3. The description adds some context (e.g., snapshot is structured only for continuation, not full conversation), but does not elaborate on most parameters beyond what the schema already provides. No per-parameter value is added.

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 it seals current work into a BATON Snapshot v1 and issues a handoff code. The verb '봉인해 발급' (seal and issue) and resource '핸드오프 코드' are specific, distinguishing it from sibling tools like baton_verify (verification) and baton_receive (receiving handoff).

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 explicit guidance on when to use this tool vs alternatives like baton_send. It does mention that providing e2e_evidence in verify parameter eliminates the need to call baton_verify separately, which is a useful hint. However, it lacks exclusion criteria or priority rules.

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

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

No annotations are provided, so the description carries the burden. It discloses that the return is wrapped in 'untrusted data' and recommends re-verification, adding context beyond the schema. However, it omits details on side effects, required permissions, or error conditions.

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

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

Three short sentences with no redundant information. The first sentence immediately states the core purpose, making it efficient for agents.

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 no output schema and minimal annotations. The description does not explain the complete return structure, error scenarios, or prerequisites. The recommendation about verification badges is vague and insufficient for robust agent usage.

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% coverage with no description for the 'code' parameter. The description only identifies it as a 'handoff code' without specifying format, validation, or examples, providing minimal additional 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 states the tool receives work context via a handoff code, which aligns with the name 'baton_receive'. It is distinct from sibling tools like 'baton_send', but lacks explicit differentiation.

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

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

No guidance on when to use this tool versus alternatives like 'baton_join' or 'baton_pass'. The description only includes a recommendation about re-verification, not usage context.

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

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

Discloses irreversible destruction (crypto-shred) and immediate action, but with no annotations, more behavioral context (e.g., permissions, side effects) would be beneficial.

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?

Single sentence, front-loaded with action, no unnecessary words.

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

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

Adequate for a simple one-parameter tool, but missing usage context and return value details.

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

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

The description adds meaning to the parameter by specifying it is a 'room/handoff code', compensating for the 0% schema coverage, but lacks format or 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 destroys/crypto-shreds a room/handoff code, distinguishing it from sibling tools that handle other operations like pass, receive, or verify.

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

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

No guidance on when to use this tool versus alternatives, no prerequisites, no when-not-to-use context.

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

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

With no annotations provided, the description must cover behavioral traits. It discloses that secrets are automatically masked and that it sends to all if 'to' is absent. However, it does not mention side effects, authorization requirements, rate limits, or error handling. The description adds value but leaves gaps.

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

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

The description is extremely concise: two sentences in Korean that cover the core action, conditional behavior, masking, and room identification. Every sentence adds value with no unnecessary words. It is well-structured and front-loaded.

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

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

Given the simplicity of the tool (3 parameters, no nested objects, no output schema), the description is largely complete. It covers the main functionality and key behaviors. However, it lacks details on return values or confirmation, and does not address potential errors. Slightly more completeness would be desirable.

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 33% (only 'to' has a description). The description compensates by explaining that 'member_id' is used to identify the room and that 'to' is optional and defaults to all. However, 'text' is not described, and the description does not elaborate on its format or constraints. It adds significant meaning beyond the schema.

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

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

The description clearly states the action (send a note) and the resource (other sessions in the room). It specifies that if 'to' is absent, it sends to all, distinguishing this tool from sibling tools like baton_receive or baton_create_room. The verb and resource 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?

The description provides usage context: 'if to is absent, sends to all' and 'knows the room by member_id'. This gives some guidance on when to use the tool, but it does not explicitly state when not to use it or compare it to alternatives like baton_receive. It lacks explicit exclusions but provides helpful context.

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

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

No annotations provided, so description carries full burden. It discloses key behaviors: creates account, no email/payment, limits, returns api_key. Does not mention potential conflicts (e.g., duplicate signup), but overall clear.

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?

Very concise, with no wasted words. Three sentences cover purpose, usage, and output handling. Front-loaded with action verb.

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

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

Given no output schema, description omits exact response format but states 'returned api_key'. Covers key aspects: account creation, limits, key usage. Lacks detail on error states or existing account handling, but adequate for a simple signup 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?

Only one parameter (api_key) with full schema description coverage (100%). Description restates schema details (optional, 12+ chars, auto-generated). Adds marginal value but does not improve upon 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?

Description clearly states 'create a free account' (무료 계정을 만든다) and explains no email/payment needed, monthly limit, and API key return. Purpose is specific but does not explicitly differentiate from sibling tools like baton_account or baton_join.

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?

Provides explicit usage guidance: when to use (anonymous trial exceeded), what to do with output (place api_key in Authorization header or pass to baton_pass), and limits (20 per month). 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?

No annotations provided, so description carries full burden. It discloses the creation of an invoice and that api_key becomes a paid account, but lacks details on reversibility, side effects, or error handling. Adequate but not comprehensive.

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 in Korean that are direct and front-loaded. No superfluous information.

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

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

Given no output schema and two parameters, the description covers the main action and side effect. It lacks details on return value format or error conditions, but for a simple tool it is fairly 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 50% with api_key described in schema. Description adds meaning by explaining that api_key becomes a paid account, which is beyond the schema. For the plan parameter, it adds context on upgrade targets. Could be more specific about format.

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 creates an upgrade invoice for Pro/Team plans and returns instructions for sending USDT/USDC to Tron or BSC wallets. It distinguishes from siblings like baton_confirm_payment and baton_verify_plan by specifying the invoice creation and payment instruction aspect.

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

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

The description implies usage when upgrading to Pro/Team plans but does not explicitly state when to use this tool versus alternatives like baton_confirm_payment or baton_verify_plan. No guidance on prerequisites or when not to use.

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

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

No annotations so description bears full burden. Discloses receipt is server-signed and unforgeable, and requires E2E observation. Does not mention error behavior, rate limits, or side effects beyond badge attachment.

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 in Korean, front-loaded with purpose. No wasted words. Efficiently conveys key points.

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

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

Tool has 8 parameters with nested objects and no output schema. Description fails to explain the receipt's structure or return behavior. Does not clarify how static_checks and e2e_evidence interact, leaving gaps for agent comprehension.

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 88% (high), so baseline 3. Description does not elaborate on parameters beyond what schema provides; concise but adds no extra 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?

Description clearly states the tool issues a signed verification receipt based on actual execution/observation. It uses specific verb '발급한다' and resource '서명된 검증 영수증'. Distinguishes from siblings by emphasizing E2E observation requirement.

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 states when to use (independent verifier with actual execution) and when not (E2E observation required, static-only insufficient). Mentions integration with baton_pass for badge, but does not name alternative tools like baton_verify_plan.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It states the tool returns a plan but does not specify if the action is read-only, involves mutations, requires permissions, or has side effects. The added context about plan components is insufficient to cover the behavioral 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?

The description is concise (two sentences) and front-loaded with the primary purpose. The second sentence adds philosophical context without redundancy, making it efficient though not perfectly structured.

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

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

With no output schema, the description should explain the return format or structure. It mentions static dimension and E2E probes but does not clarify what the plan contains or how to interpret it, leaving a significant gap for a 2-parameter tool.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description adds no new meaning beyond what the parameter descriptions provide. Baseline 3 is appropriate.

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

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

The description clearly states the tool returns a 'verification plan for the receiving-side spider' and elaborates that it includes static checks and E2E probes. However, it does not explicitly differentiate this tool from its siblings like 'baton_verify', which might serve a similar purpose.

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

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

The description implies usage for verifying actual behavior ('build pass ≠ behavior') but provides no explicit guidance on when to use this tool versus alternatives, nor any conditions or exclusions. This leaves the agent unclear about the decision boundary.

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

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

With no annotations provided, the description carries full burden. It implies a read operation but does not disclose auth requirements, rate limits, side effects, or return format. The two usage modes add some context, but overall transparency is weak.

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?

Description is extremely concise with two short sentences, each conveying essential information. No unnecessary words; it is front-loaded and efficient.

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

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

The tool has three optional parameters, no required ones, no output schema, and no annotations. The description fails to explain what the tool returns (e.g., list of member details), error conditions, or any behavioral side effects. For a simple viewer tool, it is still incomplete.

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

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

Schema coverage is 0%, so description must compensate. It explains the roles of member_id and room_id+api_key, but does not explain what api_key specifically refers to. This adds some meaning beyond the bare schema names but is incomplete.

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?

Description clearly states the tool shows room participants and specifies two usage modes (by member_id as participant or room_id+api_key as host). It is specific but does not explicitly distinguish from sibling tools, which are numerous and diverse.

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?

Description provides explicit guidance on when to use each parameter combination: member_id for participants, room_id+api_key for hosts. However, it does not advise when not to use this tool or mention alternatives among siblings.

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

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

No annotations are present, so the description carries the full burden. It discloses that when the file is missing, it merges a built-in checklist with session empirical net (privilege escalation, order, cost, event). This adds behavioral context beyond the schema, but the concept of 'session empirical net' remains vague.

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

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

The description is a single sentence, concise and front-loaded with the main purpose. However, it is slightly dense and could be broken into clearer parts. It earns its place with no waste.

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

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

Given the single parameter and no output schema, the description provides the return type and conditional merging behavior. However, it does not explain the checklist format or details of the session empirical net, leaving some ambiguity. Adequate but not fully 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?

The input schema has 100% coverage with a description listing possible dimension values. The description does not add additional meaning or syntax details beyond what the schema already provides. Baseline score is appropriate.

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

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

The description clearly states the tool returns a dimensional comprehensive checklist with a constraint (no pass without evidence). It uses a specific verb ('반환') and resource ('차원별 전수 체크리스트'), distinguishing it from sibling tools like spider_classify_tier or spider_signals.

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

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

The description implies usage for checking that no step is passed without proof, but it does not explicitly state when to use this tool versus alternatives like spider_plan or spider_record_pattern. No exclusion or alternative guidance is provided.

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

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

No annotations provided, so description carries full burden. It discloses the tool classifies and returns counts, and indicates it is a precursor to dispatch. However, it does not explicitly state if it is read-only or has side effects.

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

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

Two concise sentences with no wasted words. However, language is Korean, which may reduce accessibility for non-Korean agents.

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?

Provides core purpose and usage hint, but lacks details on output format, error conditions, or parameter relationships. Given no output schema and only 2 params, 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 has 2 parameters with 50% description coverage. Description does not explain parameters beyond the schema, and severity enum values (red/yellow/green) do not match the classification output (King/Mid/Baby), causing potential confusion.

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?

Description clearly states it classifies findings into King/Mid/Baby spiders and returns model/verification counts. It distinguishes itself from sibling spider_ tools by focusing on classification and tier assignment.

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?

States it should be called before 'fixing spider dispatch' and mentions it reflects cost/escalation/order integrity paths, providing some usage context. However, it does not explicitly specify when not to use or mention alternatives.

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

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

No annotations are provided, and the description does not disclose behavioral traits beyond the purpose. It does not mention side effects, authorization needs, rate limits, or what happens if the target is invalid. With no annotation support, more transparency is needed.

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 that front-load the key information: what the tool returns and when to call it. No superfluous words; every part 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 simple nature of the tool (2 parameters, no output schema), the description is fairly complete. It explains the output components and usage timing. Could be improved by hinting at the return format, but sufficient for decision-making.

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

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

Schema coverage is 100% with two parameters (target and thorough). The description adds minimal value beyond the schema descriptions: 'target' is restated and 'thorough' is not elaborated. Baseline 3 is appropriate as the schema already documents both parameters 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 returns a 'spider web verification plan' specifying the spider (dimension, grade, model), learning patterns to check, and absolute principles. It also indicates when to call (at round start). This distinguishes it from sibling tools like spider_checklist or spider_classify_tier, which serve different functions.

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 states 'Call at the start of a round,' providing clear usage context. Does not mention when not to use or compare directly with alternatives, but the sibling tool names suggest distinct roles, making the guidance sufficient.

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

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

With no annotations, the description carries the full burden. It discloses fallback to built-in corpus on remote failure and verified priority, but lacks details on return format, error handling, or destructive potential.

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 dense sentences covering purpose, filters, fallback, and usage context with no wasted words.

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

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

Given no output schema and 4 parameters, the description covers key aspects but lacks information on output format, empty results, or how to interpret the fetched patterns.

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 50% (2 of 4 params have descriptions). The description adds context for tags and klass as filters, partially compensating, but does not address the limit parameter or add meaning beyond schema for verified.

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 fetches verified patterns from a shared corpus, with specific filtering by tags and klass, and priority for verified patterns. It also mentions fallback behavior and a specific use case (round start trap checking), distinguishing it from siblings like spider_record_pattern.

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 clear usage context ('라운드 시작 시 알려진 함정 우선 점검용' - for checking known traps at round start) but does not explicitly state when not to use or mention alternatives among 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?

Without annotations, the description must disclose behavior. It mentions that only actually caught bugs should be recorded and that patterns are checked first next round. However, it does not detail side effects (e.g., overwrite or append), permissions required, or error conditions. This is adequate but not comprehensive.

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

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

The description is a single concise sentence that front-loads the primary action. It is efficient and to the point, though it could benefit from slightly more structure or bullet points for clarity.

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

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

Given the complexity (6 params, 5 required, no output schema), the description lacks crucial details such as return value, error handling, prerequisites (e.g., existence of a round), or integration with sibling tools. It is insufficient for a complete understanding without external knowledge.

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 100% with each parameter described in Korean. The tool description does not add extra meaning beyond the schema's parameter descriptions. Per guidelines, high coverage baseline is 3, and no additional value is provided.

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

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

The description clearly states the tool's purpose: distilling bugs caught in the current round into one-line patterns and adding them to the learning corpus, to be checked in the next round. It specifies the resource (learning corpus), action (add patterns), and scope (only actually caught bugs). This differentiates it from sibling tools like spider_pull_corpus or spider_signals.

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

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

The description implies usage after a bug-catching round, but it does not explicitly state when to use this tool versus alternatives. No exclusions or prerequisites are mentioned. The context is implied but not formally guided.

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

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

With no annotations provided, the description bears full responsibility. It describes the tool as returning signals and principles, but does not disclose behavioral traits such as read-only nature, side effects, or result structure. Lacks detail on behavior.

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

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

The description is a single concise sentence that effectively communicates the tool's purpose. It is front-loaded and to the point, though it could include a bit more detail without becoming verbose.

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

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

Given no output schema, the description should explain return format and usage details. It mentions detection signals and fix principles but does not describe structure or how to interpret them. Incomplete for a data retrieval tool.

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

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

Schema description coverage is 67% (2 of 3 parameters described). The description only mentions filtering by klass/tier/tag without adding new meaning. Baseline 3 is appropriate as the schema already provides most parameter info.

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 the tool returns detection signals and fix principles for empirical bug classes, with filtering by klass/tier/tag. It also indicates usage after planning, distinguishing it from sibling spider tools like spider_plan. However, it does not explicitly differentiate from all 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 description provides usage context: 'After planning, execute these signals as-is to collect evidence.' This implies when to use, but does not give alternatives or when not to use. No explicit exclusions.

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