baton

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

With no annotations, the description discloses read behavior and default assumptions (Free tier without api_key), adding detail beyond the schema. It does not mention side effects, but the tool appears read-only.

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-loading the main purpose and adding specific details without unnecessary words. 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?

Despite no output schema, the description fully explains what the tool returns: plan, limits, monthly usage, handoff limit, and retention period. It also covers the default api_key behavior, making it complete for an account query 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 meaning to the api_key parameter by explaining the default behavior when omitted, which goes beyond the schema's description. Given 100% schema coverage, baseline is 3, but the extra context justifies a 4.

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

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

The description clearly states the tool queries plan, limits, and monthly usage, specifying 'Handoff monthly limit' and 'retention period'. However, it does not explicitly differentiate from sibling tools like baton_verify_plan, leaving potential ambiguity.

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

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

The description provides a prerequisite note about api_key defaulting to Free, but does not explicitly state when to use this tool versus alternatives or include 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?

With no annotations, the description must disclose behavioral traits. It states the sorting order but does not mention whether the operation is read-only, the presence of pagination, rate limits, or any side effects. The agent lacks insight into the tool's runtime 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 short sentence, which is concise but omits important details. It front-loads the core purpose but lacks structure for parameters. It is adequate in length but under-specified for practical use.

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 parameter descriptions, the description is insufficient. It does not specify return format, pagination behavior, or default sorting. An agent cannot confidently invoke this tool without additional 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 coverage is 0%, and the description does not explain the two parameters ('limit' and 'specialty'). The agent cannot infer what values are valid or how they affect the output. The description adds no value beyond the schema field names.

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

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

The description clearly states the tool's purpose: to retrieve the agent marketplace sorted by verification performance. It uses a specific verb ('조회한다' - retrieves/lists) and resource ('agent marketplace'), and implicitly distinguishes from sibling tools like baton_agent_register (register) and baton_agent_record_result (record results).

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, such as baton_hub_list or baton_inbox. There is no statement about prerequisites, context, or exclusion criteria, leaving the agent without decision-making support.

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 carries full burden. It only says 'records a receipt' but does not disclose idempotency, side effects, authentication needs (beyond the api_key parameter), or whether it overwrites existing records.

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, which is concise, but it is in Korean, which may limit understanding for non-Korean agents. It lacks structured information like parameter lists or usage 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?

With no output schema, no annotations, and no parameter details, the description is severely incomplete. It fails to explain what the tool returns, how to construct a valid receipt, or any behavioral constraints.

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

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

Schema description coverage is 0%, and the description adds no information about the three parameters (api_key, agent_id, receipt). It does not explain what the receipt object expects or how agent_id is used.

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 records a signed receipt as agent performance (독립 검증자의 서명 Receipt를 agent 실적으로 기록한다). It specifies the verb (records) and resource (receipt as agent result). However, it does not differentiate from other recording tools like baton_cost_record or baton_git_record.

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 is no mention of prerequisites, context, or 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?

With no annotations, the description must disclose behavioral traits. It mentions that reputation accumulates only through independent Receipt, which is a key constraint. However, it omits other important aspects like permissions, idempotency, or side effects on existing profiles.

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 concise sentences with no redundant information. It front-loads the primary purpose and adds a key behavioral note without excess.

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 lacks information about return values (no output schema), parameter details, and prerequisites. For a registration tool with four parameters, this leaves significant gaps for the agent.

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

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

Schema description coverage is 0% and the description provides no information about any parameters (name, api_key, description, specialties). This fails to add meaning beyond the raw schema types.

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 ('register agent profile') and context ('Marketplace'), distinguishing it from siblings like baton_agent_list. The additional note about reputation accumulation adds clarity, but the term 'Marketplace' is not further explained.

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

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

No explicit guidance on when to use this tool versus alternatives. The reputation note hints at a prerequisite but does not clarify when to choose registration over listing or other agent-related tools.

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

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

No annotations are provided, so the description carries full burden. It discloses that the tool is an approval action (mutation) but lacks details on permissions, idempotency, rate limits, or side effects. For a mutation tool, this 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 concise sentence that efficiently conveys the core action. However, it lacks structure (e.g., bullet points or sections) that could improve readability. 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 the tool has 3 required parameters, no output schema, and no annotations, the description is adequate for a simple approval action but misses details like return value, idempotency, and error scenarios. It does not fully inform an AI agent about all relevant behavior.

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

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

The schema provides descriptions for 2 of 3 parameters (api_key, member_id), covering 67%. The description adds no additional parameter semantics beyond the action context. With partial coverage, a baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'approves' (승인) and the resource 'entry waiting persons in a require-approval room', which distinguishes it from siblings like baton_kick (expel) or baton_join (join). The purpose is 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 implies usage context (room with require_approval) but does not explicitly state when to use versus alternatives, such as baton_pass or baton_join. No exclusion criteria or usage conditions are 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?

The description reveals the destructive nature of the tool (destroys room, invite code, messages). No annotations are provided, so the description carries the full burden. It lacks details on prerequisites or side effects, but the core behavioral impact is 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?

The description is a single concise sentence, front-loaded with the verb and 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?

Given the tool's simplicity (2 parameters, destructive action, no output schema), the description covers the main functionality and side effects. It could mention reversibility or confirmation needs, but is largely 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?

The schema has 2 parameters with 50% description coverage. The description adds context relating api_key to the host role, but does not elaborate on room_id. The description partially compensates for the missing parameter 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 verb 'close' and the resource 'room', and specifies that it destroys the room, invite code, and messages. This distinguishes it from sibling tools like leave, kick, or 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 implies the tool is for the host to permanently close a room. While it does not explicitly state when not to use it or list alternatives, the context of sibling tools provides guidance.

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

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

No annotations are present, so the description must disclose behavioral traits. It mentions the condition that token and network must match, but does not describe what happens on failure (e.g., error messages), whether the action is irreversible, or authorization requirements. For a mutation 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 a single sentence that packs purpose, parameter list, and condition efficiently. It is not wordy, but the parameter list uses bullet points (implied by '·') which aids readability. It could be slightly more structured (e.g., separate sections).

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 (5 required params, no output schema), the description is adequate but not complete. It does not mention return values, error states, or the upgrade success criteria. Sibling tools like 'baton_upgrade' suggest possible confusion about which to use after sending a transaction.

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 lists all 5 parameters and provides enum values for 'token' and 'chain' inline. However, it does not explain the meaning of 'invoice_id', 'api_key', or 'tx_hash' beyond their names. With 0% schema description coverage, more detail would be beneficial.

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 verifies a transaction hash on-chain and upgrades a plan, specifying the action and resource. The verb 'confirm' and context of payment are evident, but it does not explicitly differentiate from siblings like 'baton_verify_plan' or 'baton_upgrade', which have overlapping purposes.

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 mention prerequisites (e.g., having an initiated payment) or situations where it is inappropriate. Sibling tools like 'baton_upgrade' exist, but no comparison is provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions consolidation and display of verification tiers, but it does not specify whether the tool is read-only, whether it modifies existing handoffs, or what side effects occur (e.g., creation of a new board). This is insufficient for a tool that likely 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?

The description is very concise: three sentences front-loaded with the core purpose, followed by the two usage modes. Every sentence adds value without redundancy. The structure is optimal 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 the moderate complexity (two modes, no output schema, no annotations), the description covers the main functionality but lacks details on output format, handling of duplicates, prerequisites (e.g., existing handoffs in room), and potential errors. The absence of output schema increases the need for more completeness here.

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 baseline is 3. The description adds meaningful context beyond the schema by explaining that codes[] is for direct input and room_id+api_key enables automatic consolidation without copy-pasting. This clarifies the relationship between parameters and usage scenarios.

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 consolidates multiple handoffs into one result board, mentioning verification tiers and who verified. It distinguishes two usage modes (direct codes or room-based) and differentiates from sibling tools like baton_verify or baton_approve by focusing on aggregation.

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 each of the two modes (codes vs. room_id+api_key), but it does not specify when NOT to use this tool or mention alternative tools among siblings. No exclusions or alternatives are given, limiting guidance for the AI 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?

Without annotations, the description carries full burden. It notes idempotency (a key behavioral trait) and implies mutation ('records'), but lacks details on error handling, duplicate behavior, authentication requirements, 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?

The single Korean sentence is concise but omits essential details. It front-loads the core purpose, but lacks structure (e.g., headings) and could benefit from explaining parameters or usage.

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 9 parameters, no output schema, no annotations, and multiple sibling tools, the description is severely incomplete. It does not explain return values, idempotency_key behavior, token fields, or how this differs from baton_cost_summary.

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 adds meaning for three parameters (provider, model, task) as grouping keys, but leaves 6 parameters (api_key, amount_usd, idempotency_key, input_tokens, output_tokens, source) unexplained, which is insufficient for a 9-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 clearly states the verb 'records' and the resource 'cost records', with grouping dimensions (provider, model, task) and idempotency. It distinguishes itself from siblings like baton_cost_summary (which likely reads) by implying this is a write operation, though not explicitly.

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

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

No guidance on when to use this tool versus alternatives such as baton_confirm_payment or baton_consolidate. The description mentions idempotency, hinting at retry safety, but does not specify conditions 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?

No annotations provided, so the description is the sole source. It discloses the basic operation but lacks details on auth requirements (api_key is required but not mentioned), whether it's read-only, rate limits, or response format.

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 a single short sentence, front-loaded. It is concise but could benefit from additional context without being 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 the single required parameter and no output schema, the description lacks completeness. It doesn't explain the input or output structure, which is insufficient for proper tool 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 0% and the description does not explain the apikey parameter. It omits any guidance on input semantics, leaving the agent to infer from the schema alone.

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

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

Description clearly states it retrieves cost and token totals grouped by provider/model/task. The verb '조회한다' indicates retrieval, and the resource is cost summary. It distinguishes from siblings like baton_cost_record (likely individual records) but without 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_cost_record or baton_account. The description only states what it does, not the context or prerequisites.

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

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

No annotations, so description carries full burden. Discloses persistence, return values (room_id, invite_code with 72h expiry), effects of alias (auto-enter) and require_approval (host approval). Could add authentication details beyond param 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?

Three concise sentences in Korean, front-loaded with the main action and return. Every sentence provides essential information without 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?

Covers creation, return values, key options. No output schema needed. Could mention success/failure cases but adequate for the complexity.

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%, but description adds value by explaining behavior of alias (auto-enter) and require_approval (host approval), which go beyond 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 clearly states the verb 'creates' and resource 'persistent team room', lists return values (room_id, invite_code), and distinguishes from siblings like baton_join, baton_close_room.

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 when to use (to create a room) but lacks explicit guidance on when not to use or alternatives. No mention of prerequisites or comparison with similar 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?

No annotations are provided, so the description bears full burden. It describes what the tool returns (diff of specific categories) but does not mention side effects, permissions, or whether it is read-only. 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?

Two concise sentences starting with the action verb 'compares'. No wasted words, front-loaded with purpose.

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 is moderately complete: it explains what the tool does and what it returns. However, parameter definitions are lacking, which 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 coverage is 0%, so the description must explain parameters. It mentions 'two handoff snapshots' but does not explicitly map them to the 'from_code' and 'to_code' parameters, leaving ambiguity.

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 compares two handoff snapshots and returns changes in specific categories (goals, status, decisions, etc.). It distinguishes from sibling tools like baton_account or baton_send.

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 example of comparing yesterday's and today's snapshots gives clear context for when to use. However, it does not explicitly state when not to use or suggest alternatives.

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

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

With no annotations, description bears full burden but only gives a single action verb. No disclosure of safety, auth needs, side effects, or output 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?

Single sentence is concise but at the expense of necessary detail. Could list more context without being 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 tool with 2 params, no output schema, and no annotations, description is too sparse to fully inform agent usage. Missing return format, usage constraints, and parameter semantics.

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 0% description coverage and description adds no parameter details. The two parameters (api_key, task_id) remain completely unexplained.

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

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

Description states verb 'query' and resource 'Git evidence ledger', providing clear purpose. However, lack of distinction from sibling 'baton_git_record' and non-English text somewhat reduce clarity.

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_git_record' or other evidence tools. Does not specify prerequisites or 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?

Without annotations, the description only adds a security note that the server does not receive credentials. It does not disclose side effects, mutability, idempotency, or any other behavioral traits, leaving significant gaps for the agent.

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 very concise at two sentences with no redundant text. However, for a tool with multiple parameters and no schema descriptions, it may be too terse and could benefit from additional structure or 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?

Given 9 parameters, no output schema, and no annotations, the description is insufficient to guide an AI on proper usage. Missing information such as parameter descriptions, return values, and use cases makes it incomplete.

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

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

Schema description coverage is 0%, and the description provides no explanation for any of the 9 parameters. Terms like 'commit_sha', 'diff_sha256', and 'test_command' are left undefined, forcing the agent to guess their meaning and formatting.

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 binds git commit, diff digest, and test results to a task. It gives a specific verb ('binding') and resource ('task'), and distinguishes itself from related siblings like baton_diff and baton_git_evidence by focusing on recording combined data to a task.

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 usage guidelines are provided. The description does not specify when to use this tool over siblings like baton_git_evidence or baton_diff, nor does it mention prerequisites or conditions for 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?

With no annotations, the description carries the full burden. It only says 'queries', implying read-only, but does not disclose any behavioral traits such as authentication needs (api_key suggests it), rate limits, or side effects. The disclosure 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 sentence with no wasted words. It could be structured better by front-loading the verb, but it is appropriately short.

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 there is no output schema and the tool has one required parameter, the description is too minimal. It does not explain what the query returns, how results are formatted, or any pagination or filtering behavior. This is incomplete for even a simple list 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 no meaning to the input schema. The single parameter 'api_key' is not mentioned, and with 0% schema description coverage, the description fails to compensate. The agent receives no additional context about the parameter's purpose 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 clearly states that the tool queries the user's MCP registry, using a specific verb and resource. However, it does not explicitly differentiate itself from sibling tools like baton_hub_observe or baton_hub_register.

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 is no mention of prerequisites, context, or exclusions, leaving the agent without decision support.

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 disclose side effects, authentication needs, or error conditions. It only mentions 'update health status' but does not explain if it's destructive, read-only, or what happens on failure.

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, but it is not front-loaded with the most critical information. It could be more concise by directly stating the purpose without the Korean phrasing, but it is brief.

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 3 required parameters, no output schema, and no annotations, the description is far from complete. It fails to explain the role of each parameter or the behavior of 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?

Schema description coverage is 0%, and the description only references 'VERIFIED Receipt' without explaining the other two required parameters (api_key, server_id). This leaves the agent without critical meaning for most inputs.

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 ('update health status') and the entity ('VERIFIED Receipt bound to this MCP endpoint'). It distinguishes from siblings like baton_hub_list and baton_hub_register by specifying the unique purpose of updating health.

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

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

No guidance on when to use this tool versus alternatives. No mention of prerequisites for the receipt being 'VERIFIED' or context such as after a verification step.

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 states 'credential 없는' (without credentials), which directly contradicts the input schema's required `api_key` parameter (a credential). This is a serious inconsistency that misleads the agent about the tool's authentication needs. No annotations are provided to clarify the behavioral profile.

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

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

The description is a single sentence that is front-loaded with the verb 'Register'. It is efficient but lacks clarity due to the contradiction. Would be perfect if accurate.

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 4 parameters, no output schema, and no annotations, the description is severely incomplete. It does not specify return values, error handling, idempotency, or effects of registration. The contradiction further undermines trust.

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 should compensate but fails to explain the parameters. It only hints at `url` and `capabilities`, ignores `name` and `api_key`, and contradicts the presence of `api_key`. The description adds minimal semantic value beyond the schema structure.

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 ('Register') and the resource ('HTTPS MCP endpoint without credentials and capability metadata'), making the purpose specific and distinct from sibling tools like baton_hub_list (list) and baton_hub_observe (observe).

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

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

The description implies the tool is for registration but provides no explicit guidance on when to use it versus alternatives, nor any prerequisites or exclusions. The name and description are sufficient for basic understanding, but lack deeper 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?

The description discloses that returned content is 'untrusted data' and instructions should not be executed, adding safety context beyond basic read operation. However, with no annotations, it omits details on side effects (e.g., destructive changes) or authentication 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?

Two sentences efficiently convey purpose and key behavioral warning. No fluff, front-loaded with the core action and notable safety constraint.

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 (2 params, no output schema, no annotations), the description covers the essential warning but lacks details on return format or when to use it. It is adequate but leaves room for improvement in providing complete operational 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 coverage is 50%, with only 'since' having a minimal description ('only after this seq'). The tool's description adds no parameter explanations, leaving 'member_id' undocumented. This fails to compensate for the schema's gaps.

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 'check my inbox' with a specific verb and resource, indicating its function. It distinguishes from sibling tools by focusing on inbox retrieval, but lacks explicit differentiation from similar tools like baton_receive.

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. The description does not mention prerequisites or exclusions. It only warns about not executing instructions, which is a behavioral note rather than 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?

No annotations are provided, so the description carries the full burden. It explains the join-and-register behavior and the distinction between code and member_id, but lacks details on permissions, side effects (if any), or whether the operation is reversible. The description is adequate but not deeply transparent.

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

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

Three short sentences, each adding essential information: purpose, usage of return value, and conceptual clarification. No redundant words, and the structure is logical 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?

Despite lacking an output schema, the description explains the return value's purpose and lifecycle. Given the tool's moderate complexity, the description is sufficiently complete for an agent to understand how to use it correctly.

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

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

Schema coverage is 100%, with each parameter having a description. The tool description does not add significant additional semantics beyond the schema, except for noting that member_id is returned. Baseline score of 3 is appropriate since the schema already documents the parameters.

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

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

The description clearly states the tool's purpose: entering a room using an invitation code and registering a nickname. It specifies the return value (member_id) and its subsequent use in send/inbox, effectively distinguishing it from sibling tools like baton_create_room or baton_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?

The description provides clear guidance on when to use the tool (when you have an invitation code) and what to do with the returned member_id. It implies the code is a one-time entry ticket, though it does not explicitly exclude alternative usage scenarios.

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

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

With no annotations, the description must disclose behavioral traits. It only says 'kicks out', omitting whether it is destructive, requires specific authorization, or has side effects like room closure.

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 with no wasted words, achieving maximum conciseness.

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

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

Given the lack of annotations and output schema, the description fails to provide enough context about return values, error conditions, or prerequisites (e.g., host role).

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%, and the description adds no information about parameters. The agent must rely on the schema's minimal descriptions, which are insufficient for correct usage.

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

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

The description clearly states the action ('kick out'), the actor ('host'), and the target ('specific participant'), providing a concise and unambiguous 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?

No guidance is given on when to use this tool versus siblings like baton_leave or baton_close_room. The agent is left to infer usage from the name 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?

With no annotations and no description of side effects, the agent cannot determine if this action is reversible, triggers notifications, or requires specific permissions. The description fails to provide any behavioral context beyond the bare action.

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 short, but conciseness is not achieved because it omits critical information. It is underspecified rather than efficiently informative.

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 of a room-leaving operation and the presence of sibling tools, the description should cover return values, side effects, and prerequisites. It fails to do so, leaving the tool's behavior largely unexplained.

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

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

The single parameter 'member_id' has no schema description, and the tool description does not clarify its purpose (e.g., whose ID it is or whether it refers to the current user). This leaves the agent guessing about valid values.

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

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

The description '방에서 나간다' (leaves the room) essentially restates the tool name 'baton_leave' without adding new detail. It does not specify the scope or distinguish from sibling tools like 'baton_kick' which also results in a member leaving.

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 (e.g., when to leave vs kick, or whether this is for self or others). There is no mention of prerequisites or 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 are provided. The description only states the action (delete) without detailing side effects, reversibility, or any other behavioral traits. Minimal information.

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, which is concise, but it omits necessary details about parameters and usage, making it slightly under-specified.

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, no annotations, and only a one-line description, the tool is inadequately documented. It lacks information on return values, prerequisites, and parameter semantics.

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 does not explain the two required parameters (api_key, memory_id). It fails to add any 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 'deletes the selected memory,' using a specific verb and resource. It distinguishes from sibling tools like baton_memory_get and baton_memory_put, though it does not explicitly differentiate.

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

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

No guidance is given on when to use this tool versus alternatives, such as when to delete vs. get or search memories.

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 fully disclose behavior. It states 'decrypt' implying a read operation, but does not mention potential errors, side effects, or whether it is read-only. Minimal behavioral context.

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, concise and to the point. However, it is so brief that it lacks structure and could benefit from additional context while remaining concise.

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

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

No output schema and no description of return values or error conditions. For a decrypt operation, more detail on output format and potential failures is expected.

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%, yet the description provides no explanation of the parameters beyond their names. It does not clarify what 'api_key' or 'memory_id' represent or how they are used.

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 action: decrypt (복호화) the memory body (기억 본문) using an API key. It distinguishes from sibling tools like baton_memory_delete, baton_memory_put, and baton_memory_search.

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 exist for different memory operations, but the description does not provide any context 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?

Description discloses encryption and cross-session storage, and that search is limited to title and tags. No annotations exist, so description carries the burden. It lacks details on error handling, idempotency, or the role of ttl_hours.

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, no fluff. First sentence defines the action, second adds behavioral constraint. Efficient use of 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 annotations, no output schema, and 0% schema coverage, the description is too brief. It does not cover return values, error scenarios, or usage examples, leaving significant gaps for a moderately complex tool.

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

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

Schema description coverage is 0%, so description must compensate. It explains api_key, title, and tags in context but omits ttl_hours entirely and does not clarify body format. Inadequate for the parameter count.

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 action: encrypt body with API key and store memory across sessions. It distinguishes the tool inherently as a put operation among memory siblings, but does not explicitly differentiate from baton_memory_get, baton_memory_search, or baton_memory_delete.

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 mentions that server search uses only title and tags, implying these should be provided meaningfully. However, it offers no explicit guidance on when to use this tool versus alternatives, 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?

No annotations are provided, so the description must disclose behavioral traits. It only states 'search metadata' without detailing read-only nature, authentication requirements, 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?

Single sentence with no wasted words. Front-loaded purpose.

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 annotations, no output schema, and 4 parameters, the description is too brief. It lacks information on output format, pagination (limit parameter), and error behavior.

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

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

Schema description coverage is 0%. The description hints at query and tags for searching title/tag metadata, but does not explain any parameter meaning or usage.

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

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

The description clearly states the tool searches metadata (title and tags) of encrypted memory. This distinguishes it from siblings like baton_memory_get and baton_memory_put.

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. The description does not mention context, exclusions, or prerequisites.

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

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

With no annotations, the description carries full burden. It reveals the 72-hour validity, the requirement for host's api_key, and the revoke_old behavior. However, it omits potential side effects, error conditions, or return values, leaving 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 with two short sentences. The main action is front-loaded in the first sentence, and every part adds value 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 moderate complexity, the description covers core behavior but lacks error handling details, prerequisites (e.g., must be host), and what the response contains. It is minimally 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 coverage is low (33%), but the description adds meaning for revoke_old by explaining its effect. For room_id and api_key, it adds little beyond the schema. The explanation of revoke_old partially compensates for low coverage.

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

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

The description clearly states that the tool issues a new 72-hour invitation code by the host. The verb '발급한다' and resource '초대코드' are specific, and the tool's function is distinct from related siblings like baton_join or baton_kick, though not explicitly differentiated.

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

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

The description implies usage context (host issuing new invite) and explains the revoke_old parameter effect. However, it does not explicitly guide when to use this tool versus siblings like baton_revoke, nor mention any 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?

No annotations provided, so description carries full burden. It discloses encryption (server cannot see plaintext), automatic secret masking, and immediate receipt issuance if e2e_evidence provided. Lacks details on destructiveness but adequately covers key 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?

Single dense paragraph front-loaded with main action. No wasted words, though some technical details could be reorganized for clarity. Efficient for its length.

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 main workflow and key parameter interactions (verify, member_id, parent_code), but lacks output schema and does not describe return format or all parameter dependencies (e.g., one_time, ttl_hours). Incomplete for a tool with 9 parameters and nested objects.

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 high (89%) with good parameter descriptions. The tool description adds overall context and flow (e.g., verify parameter usage), but does not significantly enhance individual parameter meaning beyond what 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?

Description clearly states the tool seals current work into a BATON Snapshot v1 and issues a handoff code (BTN-H-...). It distinguishes from siblings like baton_verify by noting that passing e2e_evidence in verify parameter eliminates need for separate verify call.

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 when to use: to create a handoff, and when to include e2e_evidence to avoid calling baton_verify separately. No explicit when-not-to-use, but context is clear from sibling names.

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 return is wrapped in 'untrusted data' and advises re-verification, which is crucial behavioral context given no annotations. No additional details about side effects or limitations.

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?

Extremely concise, two short sentences that front-load the essential purpose and behavior. No redundant 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?

Adequate for a simple tool with one parameter and no output schema. Covers purpose, parameter, and return handling. Could mention errors or prerequisites for full 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?

Explains the sole parameter 'code' as a handoff code, adding meaning beyond the schema. With 0% schema coverage, the description partially compensates 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?

Description clearly states the tool receives work context via a handoff code. While it differentiates from the broader 'baton' family, it does not explicitly contrast with siblings like 'baton_send'.

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 a recommendation to re-verify if no verification badge is present, which guides safe usage. However, it does not specify when not to use this tool or list alternatives.

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

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

With no annotations, the description bears full burden. It discloses immediate and irreversible destruction ('crypto-shred'), but lacks details on side effects, permissions, or error states. The destructive intent is clear, earning high marks.

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: a single sentence with one parenthetical. It is front-loaded with essential information and contains 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?

Given the simplicity of the tool, the description is adequate but incomplete. It does not mention return values, success indicators, or error conditions, leaving the agent without expectations for invocation results.

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 beyond the schema by specifying the code is a 'room/handoff code', whereas the schema only defines it as a string. This context helps the agent understand what value to provide.

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

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

The description uses the specific verb '파기한다' (destroy) and resource '방/핸드오프 코드' (room/handoff code), clearly distinguishing this tool from siblings like 'baton_approve' or 'baton_create_room' which have different focus.

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, when not to, or alternative tools. For example, it does not mention scenarios where revocation is appropriate or prerequisites like ownership of the code.

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 mentions automatic secret masking and that the room is determined from member_id, but it does not disclose side effects, permissions, 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?

Two concise sentences in Korean, front-loaded with key actions and important notes about masking and usage. 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 messaging tool with no output schema and 3 parameters, the description covers the main purpose, optional targeting, and a behavioral trait (secret masking). Missing error handling or full parameter details, but 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 coverage is only 33% (only 'to' has description). The description adds that 'to' is for a specific nickname and that member_id is used to identify the room, but 'text' remains undocumented in both schema and description.

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

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

The description clearly states it sends a note to other sessions in the room, specifies behavior when 'to' is absent (sends to all), and mentions secret masking. It is specific and distinguishes the tool's action.

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 includes a hint that code is not needed, but it does not provide explicit when-to-use or when-not-to-use guidance, nor does it compare with sibling tools like baton_approve or baton_receive.

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 account creation and limits, but omits behavioral traits like side effects, rate limits, or authentication requirements.

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

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

The description is fairly concise but mixes purpose, usage instructions, and limits in a single block. It could be better structured with separate sentences for different aspects.

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 adequately explains the return value (api_key) and how to use it, as well as relevant limits. It is complete 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?

Schema coverage is 100% (one parameter described in schema). The description adds meaning by stating the api_key is optional, must be 12+ characters, and auto-generated if omitted, which exceeds the schema's detail.

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

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

The description clearly states the tool creates a free account without email or payment, and returns an api_key. It distinguishes from anonymous trial by mentioning the 5/month limit, but does not explicitly differentiate 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 provides context for when to use the tool (creating a free account, after anonymous trial limit), but lacks explicit guidance on when not to use it or 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?

With no annotations, the description carries the full burden. It implies mutation (create) but does not disclose side effects, authorization needs, or idempotency. Missing details on how room_id and assignee affect 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 very concise with two sentences, front-loading the main purpose. However, it sacrifices necessary detail for brevity.

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

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

Given 5 parameters, no output schema, and no annotations, the description is incomplete. It does not explain return values, constraints on parameters, or the effect on the work graph.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains 'depends_on' as predecessor tasks, leaving title, api_key, room_id, and assignee unexplained.

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

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

The description clearly states it creates a task in a verifiable work graph, specifying the verb and resource. It also explains the depends_on parameter as predecessor tasks, but does not differentiate from sibling tools like baton_task_update or baton_task_link.

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 is no mention of prerequisites, context, or situations where the tool should not be used.

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 must disclose behavior. It implies a read operation via '조회한다' (query), but does not explicitly state it's read-only, nor mention authentication requirements (api_key hints at auth). No detail on side effects 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 a single sentence, front-loading the purpose. However, it is too minimal to be fully useful; conciseness is good but at the expense of completeness.

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

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

With no output schema, no annotations, and only one brief sentence, the description is incomplete. It lacks details on return format, scope ('my'), and relationship to graph structure.

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

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

Schema coverage is 0% for the single parameter api_key, and the description does not explain the parameter's purpose or format. It adds no value 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 states it queries 'my task DAG and edges', indicating a specific verb and resource. Among siblings like baton_task_create and baton_task_update, this tool is clearly about retrieving graph structure, though 'my' is ambiguous.

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

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

No guidance on when to use this tool versus alternatives (e.g., baton_task_link for edges). No context 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?

Given no annotations, the description must disclose behavior. It mentions rejecting blocks cycles, which is a behavioral constraint. But it fails to mention other important traits like idempotency (whether linking an existing edge updates or errors), authentication (api_key), or any 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?

The description consists of two short, focused sentences with no extraneous information. Every word contributes to the core purpose and a key constraint.

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 4 parameters and no output schema, the description is minimal but covers the primary action. However, it lacks parameter explanations and usage context, which is necessary for a complete understanding given the tool's complexity.

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%, yet the description only mentions edge types (blocks, relates, supersedes) without explaining each parameter's meaning. It does not describe api_key, from_task_id, or to_task_id, leaving the agent with insufficient guidance beyond the schema's type information.

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 connects two tasks with specific edge types (blocks, relates, supersedes), and mentions rejection of cycles for 'blocks'. This is a specific verb+resource that distinguishes it from sibling tools like baton_task_create (creates tasks) or baton_task_graph (displays graph).

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

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

The description provides a usage hint by stating that cycles for 'blocks' are rejected, guiding against misuse. However, it does not explicitly compare to sibling tools or specify when to use this tool versus alternatives like baton_task_create or baton_task_update.

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 carries the full burden. It only states the change action without disclosing side effects, authorization requirements, or idempotency. For a mutation tool, this 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?

Single sentence that is to the point and front-loaded with the action. 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 status update with no output schema and three required parameters, the description is minimally adequate. However, it lacks details like return value, authorization, or behavior on invalid transitions.

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%, yet the description only repeats the status enum in prose. The api_key and task_id parameters are not explained, though they are somewhat self-explanatory. The description adds some value by listing status options, but does not fully compensate for the lack of parameter 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 (변경한다/change) and the resource (task 상태/status) with the exact allowed values from the enum. It distinguishes from sibling tools like baton_task_create or baton_task_graph.

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

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

No guidance on when to use this tool versus alternatives. No mention of prerequisites, side effects, or 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?

The description mentions that the api_key becomes a paid account, indicating a state change. However, with no annotations, it does not disclose whether the operation is idempotent, reversible, or if it requires authentication beyond the api_key. Some transparency is provided, but 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 three sentences with no superfluous content. The main action is first, followed by payment details and the effect on the api_key. 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?

With no output schema, the description adequately explains what the tool returns (payment instructions). For a simple two-parameter tool, it covers the essential behavior, though it could mention expected response format or error conditions.

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 adds context about USDT/USDC and wallet networks, but does not elaborate on the 'plan' parameter beyond its enum values. It partially compensates for the schema gap.

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

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

The description clearly states that the tool generates an upgrade invoice for Pro/Team plans and returns payment instructions for USDT/USDC. It is specific about the resource (invoice) and action (generate), but does not explicitly differentiate from sibling tools like baton_verify_plan, which might cause minor 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 (e.g., baton_verify_plan, baton_account). There is no mention of prerequisites or scenarios where this tool should or should not be used.

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 carries the burden. It explains that the receipt is server-signed and cannot be forged, and that without E2E evidence it's static-only. However, it does not disclose potential side effects or authorization requirements.

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

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

The description is concise at three sentences, but it is in a single paragraph without clear structure. It effectively conveys the core purpose and caveats.

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 8 parameters, nested objects, and no output schema or annotations, the description is too brief. It does not cover return values, error scenarios, or detailed usage steps, leaving gaps for complex use cases.

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 high (88%), and the description adds minimal parameter-specific insight. The description does not elaborate on parameters beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states that the tool issues a signed verification receipt after independent verification, which distinguishes it from other baton tools. However, it could more explicitly differentiate from sibling tools like baton_verify_plan.

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 mentions that E2E observation is required for verification and that the receipt can be used with baton_pass, providing some usage context. However, it lacks explicit when-not-to-use guidance or comparison with alternatives.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It mentions the plan includes static and dynamic checks but does not state whether the tool is read-only or has side effects. For a plan-returning tool, it likely does not modify state, but this is not confirmed.

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 plus a key insight. All content is relevant and front-loaded with the core action. The quote adds useful context without excess.

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 produces a plan as output, but no output schema is provided and the description does not explain the return format or structure. For a tool that returns a complex artifact (plan), the agent needs more guidance on how to interpret the output. Input documentation is sufficient.

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

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

Input schema coverage is 100% with descriptions for both parameters ('claims' and 'target'). The description adds context about the tool's purpose but does not enhance parameter semantics beyond what the schema already provides. 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 that the tool returns a verification plan ('수신측 거미 검증 계획을 반환한다') and elaborates on its content (static dimension + E2E probes). It conveys a specific verb-resource pairing and the tool's purpose is distinct, though it does not explicitly differentiate from sibling 'baton_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?

The description implies usage context: when verification with actual observation ('완료 주장마다 실제 관측을 요구') is needed. However, it does not provide when-not-to-use guidance or mention alternative tools like 'baton_verify'. The context is present but not explicit.

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

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

No annotations are provided, so the description must convey behavioral traits. It indicates a read-only operation ('view'), which is non-destructive, but does not detail any side effects, required permissions, or response format. The parameter combinations are explained, but deeper behavioral aspects are omitted.

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

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

The description is extremely concise—a single sentence that fronts the main action ('View room participants') and then efficiently details the two parameter combinations. Every word adds value, 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?

Given the small number of parameters and absence of annotations or output schema, the description covers the essential usage scenarios. However, it could be improved by noting any prerequisites (e.g., being a room member) or the expected output format, but overall it is adequate for a straightforward 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 input schema has zero description coverage, so the description fully compensates by explaining the three parameters: member_id (for participant viewing) and room_id+api_key (for manager viewing). This adds crucial meaning beyond the raw schema, enabling correct tool invocation.

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

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

The description clearly states the tool's purpose: 'View room participants.' It specifies two distinct usage modes (participant view with member_id, manager view with room_id+api_key), which helps distinguish it from sibling tools like baton_kick 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?

The description provides context for when to use each parameter combination (participant vs. manager view), but does not explicitly exclude alternative tools or provide when-not-to-use guidance. The two modes are clearly described, which is sufficient for a simple tool.

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

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

No annotations are provided, so the description bears full burden. It discloses that the checklist merges a built-in version with session empirical data (권한상승·순서·비용·이벤트), but does not state side effects, idempotency, authentication requirements, or what happens when session data is absent.

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

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

The description is two sentences with no filler. The first sentence states the core purpose, and the second adds essential detail about merging built-in and session data. 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 a simple one-parameter tool with no output schema and no annotations, the description covers the basic functionality. However, it omits the return format and does not clarify if the tool is idempotent, leaving some ambiguity for an agent.

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

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

The single parameter 'dimension' is described in the schema with example values, and the tool description mentions '차원별' aligning with it. However, the description adds no new meaning beyond the schema's parameter description, so baseline 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 returns a full checklist per dimension, specifically a '차원별 전수 체크리스트(증거 없이 PASS 금지)', which is a distinct verb-resource pair. Among sibling tools (e.g., spider_plan, spider_classify_tier), no other tool returns a checklist, so differentiation is inherent.

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 sibling tools, such as spider_classify_tier or spider_plan. The description does not mention prerequisites, exclusion conditions, or alternatives.

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

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

No annotations are provided, so the description carries the burden. It mentions 'reflects cost, privilege escalation, order integrity paths,' which gives some behavioral insight. However, it does not disclose side effects, idempotency, or whether the tool modifies state.

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

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

Two sentences with no wasted words. The main action and usage timing are 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?

No output schema exists, but the description hints at return values ('returns model/verification count'). It does not detail the output structure or error conditions. Given the tool has two params and no annotations, more detail 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 50% (area has a description, severity does not). The description adds context by mentioning 'finding' and tier names (King/Mid/Baby) which may relate to severity, but the mapping is implicit. It compensates partially 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 verb (classify) and resource (finding into King/Mid/Baby spider tiers), and provides context about when to call (before dispatching modification spider). It distinguishes this tool from sibling tools by focusing on tier classification of findings.

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 'call before dispatching modification spider,' giving clear timing guidance. It does not list alternatives or when not to use, but the context is sufficient for most 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?

With no annotations, the description partially conveys behavior by stating it returns a plan (implying no side effects). However, it lacks details on auth requirements, rate limits, or potential state changes, leaving 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 two sentences with no redundant words. It is front-loaded, stating the primary action and outputs immediately, followed by usage timing.

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 outlines the plan's contents (spiders, patterns, principles), providing reasonable completeness. However, it could specify the structure (e.g., array or object) for full clarity.

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 descriptions for both parameters. The tool description does not add significant extra meaning beyond the schema, such as explaining how 'thorough' affects the plan. 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 spider web verification plan, listing included components (spiders, patterns, principles) and when to call it (at round start). This distinguishes it from siblings like spider_checklist or spider_classify_tier.

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

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

The description explicitly says 'call at the start of a round', providing clear context. However, it does not mention when not to use this tool or suggest alternatives, which would improve the score.

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

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

No annotations are provided, so the description carries the full burden. It discloses fallback behavior ('원격 미설정/실패 시 내장 corpus로 graceful 폴백') and filtering priority ('verified 우선'). However, it does not explicitly state whether this is a read-only operation or any side effects, which would improve transparency.

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

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

The description is two sentences in Korean, extremely concise. Every phrase adds value: purpose, filters, fallback, usage context. No wasted words, front-loaded with the most important 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 4 parameters, no output schema, and no annotations, the description provides a good overview but lacks details on return format or potential errors. It explains fallback and filters well, but limit parameter is not addressed, and the meaning of 'patterns' is assumed. 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?

Schema coverage is 50% (tags and verified have descriptions, klass and limit do not). The description adds meaning for tags and verified as filters and priority, but klass is only mentioned as a filter without elaboration, and limit is not discussed. The description partially compensates for the low coverage 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 pulls verified patterns from a shared corpus with filtering by tag/klass. It also provides usage context ('라운드 시작 시 알려진 함정 우선 점검용'). This distinguishes it from sibling tools, which are mostly baton operations or other spider utilities.

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 mentions when to use this tool (at round start for checking known pitfalls). It does not, however, provide explicit alternatives or when not to use it, but the context is clear enough 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?

No annotations are provided, so the description must disclose behavioral traits. It implies a write operation ('distill') and a constraint ('only actually caught'), but it does not mention authorization needs, side effects, or any destructive aspects. The behavioral impact is unclear.

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 in Korean, no wasted words. It front-loads the core purpose and adds a key constraint. However, it could be slightly more structured or include an example.

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 of 6 parameters and no output schema, the description is adequate but leaves gaps. It explains the overarching goal but does not detail how the tool fits into the bug detection pipeline or what happens post-recording. The sibling context hints at a broader system, but the description alone is incomplete.

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

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

Schema description coverage is 100%, and the schema already describes each parameter. The tool description does not add additional meaning beyond the schema, so the baseline of 3 is appropriate. No extra context is provided for how to fill the pattern fields.

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: to distill bugs caught in the current round into a 1-line pattern in the learning corpus for checking in the next round. The verb 'distill' and resource 'bugs into pattern' are specific, and the tool is distinguishable from siblings like spider_checklist and spider_pull_corpus.

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 minimal guidance: only record bugs that were actually caught. It does not explicitly state when to prefer this tool over alternatives (e.g., spider_pull_corpus) or when not to use it, leaving the agent with insufficient context for tool selection.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It only states that the tool returns signals and principles, without mentioning side effects, authentication needs, rate limits, or destructive potential. The read-only nature is implied by '신호' (signals) but not explicitly confirmed.

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 plus an instruction, containing no redundant words. It front-loads the core purpose and filter capability. The instruction could be considered additional useful context, making it 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 the lack of output schema, the description should explain what the returned signals and principles look like. It only vaguely mentions '탐지 신호(라이브 쿼리/grep)' without format or structure details. The tool's role in a pipeline is hinted but not fully fleshed out, leaving an agent needing more context to use it effectively.

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 67%: tag and klass have descriptions, tier only has enum values. The description adds that these are filters ('klass/tier/tag로 필터'), which provides context beyond the schema. However, it does not explain the meaning or expected format of the '신호' (signals) output, which is not defined in the schema either.

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 detection signals and fixing principles for empirical bug classes, with filters by klass/tier/tag. The verb '반환' (returns) and the resource '실증 버그 클래스의 탐지 신호' (empirical bug class detection signals) are specific. However, it does not explicitly differentiate from sibling tools like spider_checklist or spider_plan, which may have overlapping purposes.

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 includes a usage hint '계획 후 이 신호를 그대로 실행해 증거를 수집하라' (after planning, execute these signals to collect evidence), implying it should be used after planning. However, it does not specify when not to use this tool or provide alternatives among siblings, leaving the selection context vague.

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