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

With no annotations provided, the description carries the behavioral burden, and it does so well by disclosing the confirmation requirement, distinguishing the elicitation prompt path from the two-step confirmToken fallback, and explicitly stating that only a repeat call with that token proceeds. It does not cover permissions, error cases, or the final success response, but the confirmation behavior is a significant and unusual trait that is clearly communicated.

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

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

The description is compact and front-loaded with the core action, then the parameter strategies, then the confirmation flow. Every sentence adds useful information and there is no filler. The confirmation logic is complex enough to warrant the longer sentences, though the parenthetical MCP_CONFIRM_MODE reference adds a slight readability tax.

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 mutating tool with six parameters, no annotations, and no output schema, the description covers the identification modes, the confirmation requirement, and the token fallback in enough detail for an agent to invoke it correctly. It does not describe the final success response, error conditions, or parameter validation rules, but the core operational context is present.

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

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

Schema coverage is only 50%, and the description compensates by adding meaningful parameter semantics: user_id is preferred and can be resolved via sw_list_friends, and first_name + last_name + email form an explicit invite-by-email combination. The confirmToken semantics are already well-documented in the schema, and the description reinforces the 'never on the first call' rule. Minor validation constraints, such as whether email is required with name fields, are not covered.

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

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

The description opens with a specific verb and resource: 'Add a user to a Splitwise group.' It also names both supported invocation modes (user_id versus first_name + last_name + email), which gives an agent a precise picture of the operation and clearly distinguishes it from sibling tools like sw_remove_user_from_group.

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

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

It gives explicit guidance on when each input strategy should be used: prefer user_id, resolve a name via sw_list_friends, or invite by email with first/last name and email. It also explains the confirmation flow and the token fallback. It does not explicitly state when not to use the tool versus related sibling mutations, so it falls just short of a 5.

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

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

Annotations only provide destructiveHint, but the description adds meaningful behavioral context: it requires user confirmation, returns a preview, and requires a repeat call with confirmToken to actually proceed. This goes beyond the annotation and helps the agent handle a non-trivial confirmation flow. No contradiction with annotations.

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

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

Two dense sentences carry the purpose, visibility caveat, and the full confirmation behavior. The primary action is front-loaded, and every clause earns its place by explaining a necessary part of the invocation flow.

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 there is no output schema, the description provides enough about the intermediate response (preview plus confirmToken) and the repeat-call requirement. It could be slightly more explicit about the final success response, but for a simple create-comment tool with high schema coverage, the invocation context is sufficiently 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 100%, so the baseline is 3, but the description adds value by explaining how confirmToken fits into the two-step flow: it is generated after the first call and must be passed back on a repeat call. This integrates the parameter semantics into an executable sequence rather than just restating the schema.

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

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

The description opens with a specific verb and resource: 'Add a comment to a Splitwise expense.' It also states a key behavioral scope—'visible to other participants'—which distinguishes it from comment deletion tools like sw_delete_comment and from expense-creation 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?

It clearly explains the confirmation flow and when to use the confirmToken, including the two-step fallback versus the native confirmation prompt. It does not explicitly name sibling tools or say when not to use it, but the usage context is unambiguous and the confirmation instructions are actionable.

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

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

No annotations provided, so description carries full burden. It discloses the confirmation behavior in detail: first call returns preview and confirmToken, repeat call with token proceeds. Also notes that cost must be a decimal string. This is a key behavioral trait that an agent needs to know.

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 paragraph but well-organized: purpose, splitting options, cost format, and confirmation flow. It is information-dense without being verbose, and front-loads the core purpose before diving into details.

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

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

Given the tool's complexity (10 params, confirmation flow, no output schema), the description covers the essential behaviors: how to split, what to expect on confirmation, and the required format for cost. It lacks explicit mention of the return value (e.g., created expense ID), but this is commonly inferred for creation tools.

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 critical semantics: explains the mutual exclusivity of split_equally and users, the decimal string format for shares, and the confirmToken usage. Provides context beyond schema descriptions, such as 'full list of participants required' for users array.

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

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

States the specific verb 'Create' and resource 'Splitwise expense' clearly. Distinguishes from siblings like sw_update_expense and sw_delete_expense by the create action. Also clarifies the two splitting modes (equal vs custom) which is essential.

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?

Clearly indicates when to use (creating an expense) and provides guidance on choosing between split_equally and users. Doesn't explicitly mention alternatives for updating or deleting, but the create context is unambiguous. Also explains the confirmation flow which is a usage condition.

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

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

Beyond the destructiveHint annotation, the description discloses the invite side effect and the detailed two-step confirmation behavior. The fallback path (first call returns preview + confirmToken, repeat call with token actually proceeds) is explicit and non-obvious.

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

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

Two sentences, front-loaded with the core action and side effect, then the necessary confirmation protocol. The token fallback is dense but earns its place because it changes how the tool must be invoked.

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

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

The description covers the action and the confirmation workflow, including the fallback token flow, in the absence of an output schema. It does not specify token expiry or a full response shape, but it gives enough to call the tool correctly in both supported client modes.

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

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

Schema coverage is 100%, so the schema already documents all four parameters. The description adds no extra parameter-level meaning beyond what the confirmToken schema description 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 opens with 'Add a Splitwise friend by email', naming the verb, resource, and mechanism, and clarifies the invite side effect. This separates it from all sibling tools (e.g., sw_delete_friend, sw_create_group) without ambiguity.

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

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

The action and email-based scope make it clear when to select this tool, but it does not explicitly state when not to use it or compare against alternatives. The confirmation-flow note also tells the agent what to expect when invoked.

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

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

Annotations already include destructiveHint=true, indicating mutation, but the description adds crucial behavioral context: it requires user confirmation and describes the two-step fallback with a confirmToken and preview. This goes beyond the annotation and explains the confirmation flow, which is essential for correct usage.

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 redundancy: the first states the purpose, the second explains the confirmation mechanism. Information is front-loaded and every word earns its place.

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

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

Given no output schema, the description partially explains the response flow (preview and confirmToken) but does not specify what a successful final creation returns. For a tool with moderate complexity and no output schema, this is a minor gap that does not prevent correct 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 100%—all four parameters have descriptive text. The description adds no additional parameter meaning beyond the schema, so it meets the baseline for high coverage without improving or detracting from it.

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?

Clearly states the specific verb 'Create' and resource 'new Splitwise group', distinguishing it from sibling operations like sw_delete_group or sw_create_friend. The purpose is unambiguous and immediately understood.

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

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

The description does not explicitly mention when to use this tool versus alternatives such as sw_create_friend or sw_create_expense. It provides no exclusions or conditions, relying solely on the tool name for differentiation, which is implicit rather than explicit 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?

Beyond the destructiveHint annotation, the description clearly discloses the confirmation requirement, the two-step fallback mechanism, and the rule that only a repeat call with the confirmToken proceeds. This is meaningful behavioral context that an agent needs to avoid accidentally deleting a comment on the first call.

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 core action is front-loaded, and the confirmation behavior is explained efficiently in one follow-up sentence, making it easy for an agent to parse quickly.

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

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

Given the tool's destructive nature, two parameters, and lack of an output schema, the description covers everything essential: what it does, how confirmation works in both client modes, and when to pass the confirmToken. It is complete enough for an agent to call the tool safely and correctly.

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

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

Schema description coverage is 100%, so the structured schema already documents both id and confirmToken in detail. The description reinforces the confirmation flow but does not add significant new parameter-level meaning beyond what the schema provides, so the baseline score is appropriate.

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

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

The description opens with a specific verb and resource, 'Delete a comment by id', which unambiguously identifies the action and target. It is clearly distinct from sibling tools like sw_create_comment and sw_delete_expense, and the confirmation-behavior detail does not obscure the core purpose.

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

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

The description explains exactly how to invoke the tool across two confirmation modes: one prompt when the client supports elicitation, and a two-step preview/confirmToken flow otherwise. It gives clear context for when the confirmToken must be passed, though it does not explicitly discuss alternatives or exclusions beyond the tool's own flow.

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

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

Annotations only provide destructiveHint=true; the description adds substantial behavioral context beyond that: the operation is a soft-delete, it returns {success: true}, it can be reversed via undelete, and it requires user confirmation, including a two-step fallback flow. No contradiction with annotations.

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

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

Three sentences with no filler. The core action and return value are front-loaded, the reversal path is immediately given, and confirmation semantics are packed into a single clear sentence that earns its place.

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

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

Given the tool's complexity and lack of an output schema, the description covers the essential behavior, return value, restore path, and confirmation edge cases. It leaves the exact phase-1 preview structure to MCP_CONFIRM_MODE rather than spelling it out, a minor gap.

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

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

Schema coverage is 100%, and both parameters are already well documented in the input schema, especially confirmToken. The description summarizes the confirmation flow but does not add significant new per-parameter meaning beyond the schema's own descriptions, so the baseline of 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Soft-delete a Splitwise expense by id.' It also distinguishes this from restore by naming sw_undelete_expense as the reversal path, making the purpose unambiguous among 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?

It explicitly names the alternative for restoration and gives a precise usage protocol for confirmation: prompt first where supported, otherwise preview + confirmToken on the first call and proceed only on a repeat call with the token. This leaves no ambiguity about when and how to invoke the tool or the token.

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

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

Annotations already declare destructiveHint=true, so the destructive nature is known. The description adds valuable context by explaining the confirmation flow: a prompt where supported, or a two-step fallback with confirmToken. This is crucial behavioral information beyond the annotation and helps the agent handle the tool correctly.

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 the core action front-loaded and the confirmation detail following. There is no fluff or redundant information, making it efficient and easy to parse.

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 destructive tool with a confirmation mechanism, the description covers the essential behavior, including the two-step fallback. It lacks details on error handling or response format, but given the absence of an output schema and the clarity of the confirmation process, it is reasonably complete for an agent to invoke correctly.

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

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

Schema description coverage is 100%, so both parameters are already well-documented. The description adds some context about the confirmation flow and references MCP_CONFIRM_MODE, but it does not add new parameter semantics beyond what the schema provides, especially for confirmToken which is already detailed.

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

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

The description states a specific verb ('Remove') and resource ('Splitwise friendship'), clearly distinguishing it from other delete tools like sw_delete_group or sw_delete_expense. The user id parameter is explicitly mentioned, making the tool's purpose unambiguous.

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

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

The description implies usage by stating the action, but does not explicitly mention when to use this tool versus alternatives or any exclusions. It focuses on the confirmation process rather than selection criteria, leaving the agent to infer when to choose this tool.

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

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

The description adds significant behavioral detail beyond the destructiveHint annotation by explaining the two-step confirmation mechanism: the client-support path and the fallback token flow. It transparently states that the first call returns a preview and confirmToken, and that a repeat call proceeds only with that token. This is exactly the kind of extra context an agent needs to avoid unintended deletions.

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

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

The description is a single, well-structured sentence that front-loads the primary purpose and then explains the confirmation behavior. Every clause earns its place, with no redundant phrases or filler. It is concise without sacrificing necessary 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?

For a deletion tool with a two-step confirmation flow and no output schema, the description covers the critical interaction pattern, including the return of a preview and confirmToken. It does not explicitly state the post-deletion state (e.g., whether the group is hidden or available via undelete), but 'soft-delete' implies this, and the existence of sw_undelete_group provides additional context. The reference to MCP_CONFIRM_MODE is an external dependency but is acceptable.

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% for both parameters, so the baseline is 3. The description adds no new meaning for the 'id' parameter, and for 'confirmToken' it largely reiterates what the schema already explains in detail. The only added value is the pointer to MCP_CONFIRM_MODE, which slightly enhances understanding but does not compensate for a high baseline.

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 ('Soft-delete a Splitwise group') with a specific verb and resource. It distinguishes from siblings like sw_create_group or sw_update_group by indicating deletion semantics, and the 'soft' qualifier implies reversibility, setting it apart from a permanent 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?

The description explains the confirmation flow, which is crucial for correct usage, and references MCP_CONFIRM_MODE for context. However, it does not explicitly mention when to prefer this over alternatives like sw_undelete_group (for reversal) or when not to use it, leaving some inference to the 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?

Annotations declare readOnlyHint=true, and the description adds the 'hierarchical' nature of the list, which is useful but limited. No additional behavioral context like pagination or structure is given, but the read-only trait is already covered by annotations.

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

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

The description is two short sentences that directly state the purpose and practical usage. No filler or redundancy, every word earns its place.

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

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

The tool is simple with no parameters and a read-only annotation. The description adequately conveys what is returned (hierarchical categories) and how to use the result. It does not specify the exact structure, but that is acceptable for this minimal 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?

With zero parameters, the schema fully covers parameter semantics (100% coverage). The description adds value by explaining the purpose of the returned id, which indirectly supports the output usage rather than parameters. Baseline of 4 is appropriate for 0 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 retrieves a 'hierarchical list of Splitwise expense categories,' using a specific verb and resource. It differentiates from sibling tools which focus on groups, users, friends, and expenses.

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

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

The description provides explicit workflow guidance: 'Use the returned id as category_id when creating expenses.' This tells when to use the tool, though it does not mention exclusions or alternatives, which are not necessary here.

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

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

Annotations already declare readOnlyHint=true, so the description's minimal additional context (that it returns all comments for an expense) is acceptable. It does not disclose potential limits or edge cases (e.g., what happens with no comments, pagination), but for a read-only getter this is not critical. No contradictions with annotations.

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

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

The description is a single, concise sentence that immediately states the tool's purpose. No wasted words, and it is front-loaded with the action and resource. Perfectly sized.

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

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

For a simple read-only getter with two parameters (one required), no output schema, and readOnlyHint annotation, the description is fully adequate. It states the purpose and the schema covers the rest. An agent can confidently invoke this tool with just the expense_id.

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 provides detailed descriptions for both expense_id and view (including the compact/full semantics). The tool description adds nothing about parameters beyond what the schema covers, so the 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 'Get all comments on a Splitwise expense' clearly states the verb (Get), the resource (comments), and the scope (on a specific expense). It unambiguously distinguishes this from sibling tools like create_comment and delete_comment, and from expense/group getters. No 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?

While the description does not explicitly mention when not to use it or name alternatives, the context is clear: it is the only tool for retrieving comments on an expense. The purpose inherently defines its usage, and there are no competing getters for comments. This meets the 'clear context, no exclusions' bar.

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 readOnlyHint annotation already establishes that this is a safe read operation. The description adds the detail that it returns both codes and units and that the currency_code is used for expense creation, but it doesn't disclose additional behavioral traits like return format or pagination. The annotation covers the safety profile, so this is adequate but not exceptional.

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: the first states the exact function, the second provides usage context. There is no filler or redundancy, making it highly concise and well-structured.

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

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

Given the tool's simplicity (no parameters, no output schema, readOnly annotation), the description fully covers what the tool does and how to use the result. It mentions the returned data (codes and units) and gives a concrete application, making it complete for its 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?

The tool has zero parameters, so there are no parameter semantics to explain. The schema is empty and fully self-descriptive. The description doesn't need to compensate, so the baseline score of 4 applies.

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

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

The description uses the specific verb 'Get' and clearly identifies the resource: Splitwise-supported currency codes and units. It is distinct from sibling tools that handle groups, users, expenses, etc., so the purpose is unambiguous.

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

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

The description provides actionable guidance: 'Use the currency_code value when creating expenses in non-default currencies.' This tells the agent when the retrieved data is relevant. It doesn't explicitly mention when not to use this tool or name alternatives, but there are no currency-specific siblings, so the context is clear.

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

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

Annotations declare readOnlyHint=true, so the safety profile is already covered. The description adds valuable behavioral detail beyond annotations: the default compact response shape, the effects of view:'full', and the important consequence that first_name and last_name are joined in compact but separate in full. This helps an agent anticipate the exact return shape without needing an output schema.

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

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

The description is tightly written: a single-purpose opening sentence followed by a compact explanation of the view parameter's behavioral difference. No filler words, and the most important information (what the tool returns and why the id matters) is front-loaded.

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

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

For a simple, read-only tool with one optional parameter, the description covers everything an agent needs: what the tool returns, the exact fields in each view, and how the output connects to related operations like sw_update_user. The readOnly annotation and rich parameter schema remove the need for additional safety or return-format detail.

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%, so the view parameter is already well documented. The description still adds meaning by connecting view:'full' to the data shape required by sw_update_user, giving the agent a concrete reason to choose one view over the other beyond the schema text.

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

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

States a specific verb and resource: 'Get the authenticated Splitwise user's profile.' The word 'current' plus 'authenticated' clearly distinguishes it from sibling sw_get_user, and the description explicitly orients the agent toward using the returned id in custom expense splits.

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

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

Provides clear context for when to use the tool—obtaining the current user's id for expense splits—and explains when to choose compact vs full view. It does not explicitly name sw_get_user as an alternative, but the 'authenticated current user' framing is sufficient to route an agent to the correct 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?

The readOnlyHint annotation already establishes that this is a safe read operation. The description adds that it returns 'full details' of the specified expense, but it does not disclose other behavioral aspects such as authentication requirements, error behavior, or whether the default response is actually compact rather than full.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It conveys the essential purpose and resource immediately.

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 low-complexity, read-only tool with well-documented parameters, the description is nearly complete. It lacks an explicit statement of return shape or an alternative reference, but the phrase 'full details' and the view parameter documentation give an agent enough context to invoke it correctly.

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

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

Schema description coverage is 100%, and both the id and view parameters are already well documented in the schema. The description adds no additional parameter-level meaning beyond reinforcing the need for an expense ID, so it stays at the baseline.

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

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

The description clearly states a specific verb ('Get'), a specific resource ('a single Splitwise expense'), and the mechanism ('by id'). It distinguishes itself from list, create, update, and delete expense siblings by emphasizing detail retrieval for one expense.

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

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

The description implies the tool should be used when an agent has an expense ID and needs full details for a single expense. However, it does not explicitly mention alternatives like sw_list_expenses for fetching multiple expenses or sw_update_expense for modifications, leaving usage selection mostly to inference.

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

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

Annotations declare readOnlyHint=true, so the agent knows this is a safe read operation. The description adds value by specifying the response includes members and balances, and the 'view' parameter description discloses significant behavioral details about response size and what fields are dropped in compact mode. This goes beyond the annotation.

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

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

The main description is a single clear sentence. The 'view' parameter description is longer but earns its place by explaining a non-obvious tradeoff. The structure is front-loaded with the core purpose before parameter details.

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

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

For a read-only single-resource tool with 100% schema coverage and a clear description, the definition is largely complete. The output schema is absent, but the description mentions the key return contents (members and balances). The 'view' parameter explanation covers the main behavioral nuance. Minor gap: no explicit mention of error cases or 404 behavior, but this is not critical for a simple GET-like tool.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description adds meaningful context for the 'view' parameter by explaining the practical impact of compact vs full (response size, dropped fields), which is valuable beyond the schema's enum description. The 'id' parameter is simple and adequately described.

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

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

The description states a specific verb ('Get'), a specific resource ('a single Splitwise group'), and the key included data ('all members and balances'). This clearly distinguishes it from sibling tools like sw_list_groups (which lists groups) and sw_get_expense (which gets an expense).

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

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

The description implies usage for retrieving a single group's details, but it does not explicitly state when to use this tool versus alternatives like sw_list_groups. The sibling list provides context, but the description itself offers no direct comparison or exclusion criteria.

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

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

The annotations already declare readOnlyHint=true, and the description's 'Get' is consistent with a read operation. The description adds 'recent' and 'current user' scope but does not disclose details such as ordering, pagination, or what counts as an activity notification. For a simple read-only tool, this is minimally acceptable but adds little beyond the annotation.

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

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

The description is a single, front-loaded sentence with no filler or redundant phrasing. It efficiently conveys verb, resource, and scope, though it could have used the space to add routing or behavioral 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?

This is a low-complexity tool: one optional parameter, no required fields, and a clear purpose. The read-only annotation and full schema coverage cover most context needs, though the description does not describe the response shape or notification ordering, which would be helpful since no output schema exists. It is adequate but not maximally complete.

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

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

The schema fully documents the only parameter, 'view', including what 'compact' versus 'full' returns and that compact drops avatar URLs. The description itself adds no parameter information, so the schema carries the full burden. This aligns with the baseline of 3 for high schema coverage.

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

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

The description states a specific verb ('Get'), resource ('Splitwise activity notifications'), and scope ('for the current user'). It is clearly distinguishable from sibling getters because no other sibling targets notifications. However, it does not explicitly contrast itself with any sibling, so the top score is not quite earned.

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 this tool is for retrieving the current user's recent activity notifications, but it gives no explicit when-to-use or when-not-to-use guidance and names no alternatives. Since there is no sibling notification tool, the ambiguity is mild, but routing guidance is still absent.

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

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

The description adds significant behavioral context beyond the annotations: it discloses the 401 auth issue, the file-writing side effect, the read-only fallback, the 4MB inline limit, and PDF text extraction behavior. It does not contradict readOnlyHint=false or destructiveHint=false.

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

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

The description is four sentences with no filler. The core action is front-loaded, followed by the 401 caveat, mode options, and write behavior. Each sentence earns its place with operational 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?

For a 6-parameter tool with no output schema, the description covers the main return channels (file path, inline bytes, extracted text), the key failure mode (401 on direct URL fetch), and filesystem constraints. It does not specify edge cases like missing receipts or the exact response envelope, but the schema handles remaining parameter details.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful semantics to inline, extract_text, and write by explaining their practical use cases and the returned path. However, size and output_dir are still primarily explained by the schema rather than the 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 states a specific verb and resource: 'Download the receipt image or PDF attached to a Splitwise expense.' It also distinguishes itself from sibling sw_get_expense by explaining that the receipt URLs returned by sw_get_expense require server credentials and this tool should be used instead.

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

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

It explicitly tells the agent to use this tool rather than fetching receipt URLs directly, because those URLs return 401 without server credentials. It also gives conditional guidance for inline:true, extract_text:true, and write:false, covering the key decision of whether the caller can access the server's filesystem.

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 readOnlyHint annotation already covers the safety profile, so the bar is lower. The description adds meaningful behavioral context by explaining the default compact response merges first_name/last_name into name while view:'full' keeps them separate. No contradiction with annotations.

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

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

Two sentences with no fluff: the first states the purpose, the second covers the shape semantics and references the sibling. Both sentences earn their place and the key scoping detail ('another', 'by id') is front-loaded.

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

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

Core invocation details (id, view, shape, read-only nature) are well covered by the description and schema even though no output schema exists. Minor gaps like access requirements (e.g., friendship with the target user) or error behavior are not disclosed, but for a simple get-by-id tool this is acceptable.

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

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

Schema coverage is 100%, and the schema already fully documents both 'id' and 'view', including the compact/full field behavior. The description repeats the merge distinction but does not add new parameter-level meaning beyond what the schema provides, so the 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?

Description states a specific verb ('Get'), resource ('another Splitwise user's profile'), and identifier ('by id'), and differentiates itself from sw_get_current_user by targeting another user rather than the current one. The purpose is immediately clear and distinct from the sibling set.

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

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

The description clearly implies when to use the tool: to fetch a different user's profile by id, in contrast to sw_get_current_user for the current user. It does not provide explicit when-not or alternative routing, but the 'another' vs 'current' distinction and the sibling mention give adequate 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?

Annotations already mark this read-only and idempotent, but the description adds valuable behavioral context: it never returns the credential itself, resolves the credential through the same path as real tools, and performs exactly one authenticated request. There is no contradiction with the annotations.

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

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

The description is compact and front-loaded: purpose first, then output details, then the read-only caveat, then the trigger condition. Every sentence earns its place and there is no filler.

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

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

Even without an output schema, the description enumerates the returned diagnostic fields (credential source, acceptance, round-trip time, failure hint) and the failure classes it distinguishes. For a zero-parameter healthcheck tool, this is sufficient for an agent to understand and interpret the result.

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

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

The tool has zero parameters, so the description carries no burden to explain parameter meaning. Per the baseline for zero-parameter tools, this is appropriately handled; the description instead clarifies what the tool reports, which is what matters for invocation.

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

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

The description states a precise diagnostic purpose: resolve credentials the way real tools do, make one authenticated request, and report which hop broke. This clearly distinguishes it from sibling data and mutation tools, so an agent can select it for healthcheck rather than for normal CRUD operations.

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

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

The description explicitly tells the agent when to call it: 'Call this when a real tool fails and you want to know which hop broke.' It provides clear context for use, though it does not explicitly say when not to use it or name alternatives.

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

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

The annotation readOnlyHint=true already covers the safety profile, and the description adds little beyond it. It states that all filters are optional and gives filter examples, but these are redundant with the schema and don't disclose additional behavioral traits such as pagination defaults, rate limits, response shape, or auth requirements. For a list tool, the absence of pagination behavior or API limits is a meaningful gap.

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

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

The description is three short sentences with no fluff. It front-loads the purpose ('List or search Splitwise expenses') before giving filter guidance. It earns its place, though it could be even more structured by grouping the filter types, but overall it's concise and efficient.

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

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

For a tool with 9 optional parameters and no output schema, the description is thin. It doesn't mention pagination mechanics (limit/offset), what the response looks like, or any default behavior beyond 'all filters optional.' An agent invoking this tool for the first time would still wonder how results are returned and whether there are hidden constraints. The annotations cover safety, but not the operational details needed for correct use.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters. The description adds slight value by highlighting group_id and dated_after/dated_before as common filters, but it doesn't enrich the meaning of any parameter beyond the schema. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description states a clear verb and resource: 'List or search Splitwise expenses.' It conveys the general action of retrieving expenses, and the mention of filters suggests a listing/search capability. It doesn't explicitly name a sibling to differentiate from, but 'list expenses' is distinct from 'get expense' and other group/friend operations, so an agent can reasonably tell it apart.

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 by saying 'List or search Splitwise expenses' and notes that all filters are optional, with examples of filtering by group and date. However, it provides no explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives like sw_get_expense for single-expense retrieval. The guidance is adequate only at an implied level.

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

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

Annotations already mark readOnlyHint=true, signaling a safe read operation. The description adds value by disclosing the default response shape, the fields returned, the non-empty balance behavior, and the difference between compact and full views.

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

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

Three sentences with no filler: purpose, use case, and view semantics are each front-loaded and each sentence carries distinct 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?

For a zero-required-parameter read-only list tool, the definition fully explains what an agent needs: why to call it, what the default returns, and how to get the fuller representation. The absence of an output schema is compensated by the descriptive coverage.

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 'view' is already fully documented in the schema with enum values and exact response differences, so the description adds only marginal value beyond the schema. This matches the baseline for high schema coverage.

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

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

The description opens with a specific verb and resource: 'List all Splitwise friends.' It also states the practical purpose, resolving a friend's name to a user_id, and is clearly distinct from sibling list_* tools by naming the friends resource.

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 when to use it: before adding a friend to a group or building a custom expense split. It does not name excluded alternatives, but the intended context is unambiguous.

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 readOnlyHint=true in annotations, the safety profile is already covered. The description adds meaningful behavioral context by stating the scope ('all groups the current user belongs to') and the returned subset (id, name, members). No contradictions with the annotation exist.

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

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

The description is two tight sentences with no filler. The first sentence states action, scope, and return fields; the second gives a practical use case. Information is front-loaded and every word earns its place.

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

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

For a simple read-only list tool with zero required parameters and no output schema, the description covers the essential facts: what is listed, whose perspective, what fields are returned, and why an agent would call it. Nothing critical is missing given the tool's low 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 description coverage is 100%, and the view parameter has a detailed explanation of compact versus full response shapes. The tool description itself adds no parameter-level meaning, but the baseline is 3 because the schema already documents the only parameter thoroughly.

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

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

The description states a specific verb ('List'), a clear resource ('all Splitwise groups'), and a scoping qualifier ('the current user belongs to'). It also names the key return fields (id, name, members), and the sentence 'Use this to resolve a group name to its id' sharpens the purpose. This distinguishes it from sibling sw_get_group, which targets a single group.

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

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

The description gives an explicit use case: 'Use this to resolve a group name to its id.' This tells an agent when to invoke the tool. However, it does not mention when not to use it or point to alternatives such as sw_get_group for detailed single-group data, so it falls short of full routing 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?

The description goes well beyond the destructiveHint annotation by explaining the two-step confirmation mechanism: a confirmation prompt for supporting clients, and a preview/confirmToken fallback for others. It also clearly states that a repeat call with the token is required and that the token must never be invented or reused.

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 core purpose is front-loaded, and the necessary confirmation behavior is stated compactly afterward.

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 sufficiently explains the destructive action and the unusual two-step confirmation flow, which is the main risk when calling this tool. Minor omissions like the exact shape of the preview or final success response are not critical for invocation, especially since no output schema is provided.

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

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

Schema coverage is 100%, and the confirmToken parameter already has a detailed schema description. The tool description does not add significant semantic meaning beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb ('Remove') and resource ('a user from a Splitwise group'), making the action unambiguous. It is clearly distinguishable from sibling tools like sw_add_user_to_group and sw_delete_group.

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 purpose statement gives clear context for when the tool applies, and the confirmation-flow detail helps the agent understand the expected call pattern. However, it does not explicitly name alternatives or state when not to use this tool.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action 'restore' which implies a state-changing operation, but it does not disclose what happens if the expense is not soft-deleted, whether the operation is idempotent, or any error conditions. The behavioral transparency 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 extraneous words. It front-loads the verb and resource, making the purpose immediately clear. There is zero waste.

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

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

For a simple tool with one parameter and no output schema, the description is adequate for basic use. However, it lacks details about edge cases (e.g., behavior when the expense is not soft-deleted) and does not mention permissions or idempotency. While not incomplete for a trivial operation, it leaves some ambiguity that a more thorough description could resolve.

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% – the id parameter has a description 'Expense ID to restore'. The tool description adds no additional semantic information beyond the schema. With high coverage, the baseline is 3, and the description does not elevate it further.

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

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

The description uses a specific verb 'Restore' and a specific resource 'soft-deleted Splitwise expense', making the tool's purpose unambiguous. It clearly distinguishes from siblings like sw_delete_expense (which deletes) and sw_undelete_group (which restores a group, not an expense).

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 use case: when you have a soft-deleted expense and want to bring it back. However, it does not provide explicit guidance on when not to use it, nor does it mention any prerequisites (e.g., the expense must be in a deleted state) or alternatives (e.g., other restore tools). The guidance is implicit rather than explicit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the core behavior and the required prior state, but does not mention side effects, permissions, idempotency, or whether the restored group brings back members and expenses.

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

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

A single sentence that states the verb, resource, and precondition with no filler. It is appropriately sized for a one-parameter restore operation.

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

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

For a simple one-parameter tool with no output schema, the description is mostly sufficient for selection and invocation, but because there are no annotations it omits return/error behavior and the practical meaning of restoration. The interaction with sw_delete_group or how soft-deleted groups are identified is left to inference.

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

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

The input schema already covers the only parameter with a clear description ('Group ID to restore'), and schema coverage is 100%. The tool description does not need to add much, but it also does not clarify ID format or how an agent can find soft-deleted group IDs.

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

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

The description names a specific action ('restore') and a precise target ('soft-deleted Splitwise group'), so an agent can tell this from sw_get_group, sw_delete_group, or sw_undelete_expense without extra context. It goes beyond the tool name by clarifying the object must already be soft-deleted.

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 precondition 'soft-deleted' implies this tool should be used only for groups that have been deleted but not permanently removed. It does not explicitly mention when not to use it, compare it with sw_delete_group, or point to alternatives such as sw_undelete_expense for expenses.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses the confirmation prompt behavior, the preview/confirmToken fallback, and the fact that the API replaces the entire custom split rather than merging changes. This is substantial, though it does not discuss permission requirements or reversibility beyond the implied edit operation.

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

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

The description is dense but every sentence adds essential information: the basic edit action, the split-replacement caveat, and the confirmation flow. It is front-loaded with the primary purpose and contains no filler.

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

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

For a 10-parameter mutation tool with no annotations and no output schema, the description covers the key invocation hazards: required expense_id, full users array replacement, and the two-step confirmation protocol. It does not explain the success response shape of the final call, but the confirmation/preview flow is sufficiently described for an agent to call the tool correctly.

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

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

Schema description coverage is only 50%, so the description needed to compensate for undocumented parameters. It does explain the critical semantics of users (full replacement array) and confirmToken (only on repeat calls after approval), but other parameters like date, details, category_id, and currency_code receive no added meaning beyond their names. The description is adequate but leaves clear 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 opens with a specific verb and resource: 'Edit an existing Splitwise expense.' It clearly distinguishes editing from the sibling create/delete/undelete expense tools and tells the agent exactly what action this tool performs.

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 states to provide expense_id and any fields to change, and gives specific conditions for custom split updates and two-step confirmation. It does not explicitly name alternatives like sw_create_expense or sw_delete_expense, but the 'existing expense' framing plus sibling names makes the appropriate context clear.

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

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

Annotations already establish that this is a mutating operation (readOnlyHint=false, destructiveHint=true), so the description does not need to restate that. It adds meaningful behavioral context: the confirmation requirement, the confirmToken handshake, and the credential exclusion. It could further clarify whether omitted fields are left unchanged, but it still provides substantial transparency beyond the annotations.

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

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

The description is two dense sentences with no filler. The core operation comes first, followed by the identity constraint, the credential exclusion, and the confirmation protocol. Referencing MCP_CONFIRM_MODE avoids repeating platform mechanics. Every clause earns its place.

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

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

For a six-parameter mutating tool with no output schema, the description covers the required fields, the current-user restriction, the intentionally non-settable fields, and both confirmation paths. An agent has enough information to decide whether to call it, what arguments to pass, and how to complete the two-step confirmation fallback. The key return behavior is described precisely as needed.

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

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

With only 33% schema description coverage, the description carries real weight for parameter meaning. It names the domain fields (name, locale, default currency) and explains the confirmToken lifecycle, which is the tool's most subtle parameter. It slightly underspecifies by collapsing first_name and last_name into 'name,' and it doesn't give locale/currency formats, but it compensates well overall for a low-coverage schema.

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

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

The description opens with a specific verb and resource — 'Update the current user's profile fields' — and enumerates the exact updatable areas: name, locale, and default currency. The restriction 'id must be the current user's id' removes ambiguity about scope and distinguishes this from any other user-oriented operation. An agent can tell immediately what this tool does and what it does not do.

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 sets a boundary: login email and password are 'deliberately not settable here' and belong to the Splitwise app, not an assistant. It also explains the confirmation workflow, including the fallback path where the first call returns a preview and confirmToken and only a repeat call proceeds. This gives an agent clear when-to-use and when-not-to-use guidance.

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