Xupersplit

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

Annotations only declare readOnlyHint=false and destructiveHint=false, which already signal mutation. The description adds valuable context: the default equal-split behavior, options for subset or uneven splits, the 'one expense per set of people' constraint, and the secure-split restriction. It doesn't detail exact API behaviors like idempotency or return values, but the output schema covers return structure.

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

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

Four sentences, every one earns its place. The flagship sentence explains default behavior and options; the second resolves the multi-item receipt ambiguity; the third scopes to 'simple, accountless splits'; the fourth gives the secure-split exclusion. No filler or repetition of schema text.

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 7 params (full schema coverage) and rich output schema, the description is complete: it explains the decision rule for multi-expense receipts, the three split modes (equal/subset/uneven), the secure-split limitation, and the accountless scope. The main behavioral caveats are all disclosed given annotations and output schema already cover safety and return shape.

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?

Though schema coverage is 100%, the description adds substantial semantic clarity: it explains that split_between overrides the equal-split default, shares handles uneven splits (tied to the schema's amount/weight dual modes), and paid_by references a participant name. The description ties parameters into the core decision flow (default vs subset vs uneven), which the schema's individual descriptions don't fully convey.

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

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

The description uses a specific verb ('Record something one person paid for the group') that clearly identifies the resource and action. It also differentiates from the sibling tool 'record_payment' by clarifying this is about expenses paid by one person for the group, and the multi-expense nuance (receipt with non-shared items = several expenses) strongly distinguishes its scope.

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 covers when to call once per group of items shared by the same people, explaining the split-vs-several-expenses decision rule. It also gives exclusions by stating secure splits are read-only and must be opened in a browser, which tells the agent 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?

With annotations present (destructiveHint=false, readOnlyHint=false), the description adds valuable context beyond them: the split-type constraint (simple vs secure), and the browser redirect behavior for secure splits. This clarifies a significant behavioral limitation that annotations alone could not convey.

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, zero waste. The description front-loads the core purpose, then adds the scoping constraint and the browser caveat. Every sentence earns its place with no redundant phrasing.

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

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

With an output schema present, the return shape is already documented. The description effectively covers the key operational constraint (split type) and the alternative path for secure splits. For a 2-parameter, low-complexity tool, this is well-covered. The only minor gap is that it doesn't mention what happens on failure (e.g., split not found).

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%, meaning the split parameter is documented in the schema but the name parameter has no description. The description mentions 'Add someone' which implies the name field's role, but doesn't elaborate on the split parameter's acceptable formats beyond what the schema already states ('split key, or whole link'). Baseline 3 is appropriate since the schema handles much of the 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 states a specific verb+resource ('Add someone to an existing split') and clearly scopes functionality by distinguishing simple splits from secure splits, which are read-only here. It differentiates from siblings like remove_participant and rename_participant by naming the specific operation.

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

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

The description clearly states when the tool applies ('simple, accountless splits') and gives an explicit exclusion ('Secure splits... are read-only here and must be opened in a browser'). This provides strong context, though it doesn't name alternative tools for secure splits or mention other sibling alternatives in the same domain.

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 annotations only declaring non-readOnly and non-destructive (neutral), the description adds substantial behavioral context: no account needed, returns a secret link, and anyone holding the link can see and edit. This is meaningful transparency beyond 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, zero waste. It delivers purpose, usage instruction, and behavioral warning in a compact, front-loaded manner with 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?

The tool has an output schema, so return values are covered. The description adequately addresses the creation flow, security implications, and authentication-free nature. It could slightly expand on what a 'xupersplit' is, but the context is sufficient for a creation tool with rich schema and output schema.

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

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

Schema description coverage is 100%, so all three parameters (title, currency, participants) are documented in the schema. The description adds no parameter-specific semantics, but the schema fully covers them, so the baseline of 3 applies.

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

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

The description clearly states it creates a new xupersplit for sharing expenses in a group, with a specific verb+resource. It includes a key distinguishing detail (returns a secret link) that differentiates it from sibling tools like update_split or get_split.

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 what to do with the returned link ('give it to the user and tell them to share it with the group') and conveys an important security caution about link holders. It doesn't explicitly name alternatives or when-not-to-use, but the creation intent is self-evident against 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?

The annotations already declare destructiveHint=true and readOnlyHint=false, so the destructive nature is covered by structured data. The description adds valuable context beyond annotations by explaining the limitation that secure splits are read-only here and must be opened in a browser, which is behavioral behavior not disclosed by annotations alone.

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 carry complete information with zero waste. The first sentence states the action and its scope; the second covers the exclusion and alternative. 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?

With a destructive action, accurate annotations (destructiveHint=true), full schema coverage, and an output schema present, the description covers the essential behavioral boundary (secure vs. simple splits) that the schema cannot express. It's complete enough for this 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 100% for both parameters (split and entry_id), with the split parameter even documenting the acceptable key-or-URL form. The description itself doesn't add parameter detail beyond the schema, but with full coverage the baseline of 3 is appropriate. The description implies the entry_id relates to removal but adds no additional meaning.

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

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

The description states a specific verb+resource ('Remove an expense or payment') and clearly distinguishes its scope from siblings by explicitly noting it only works on simple, accountless splits and that secure splits are read-only here. This differentiates it well from update_entry, which would modify rather than 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 explicitly states when to use this tool (simple, accountless splits) and when NOT to use it (secure splits created by signed-in users), with an alternative action (open in a browser). This is strong exclusion guidance that directly aids 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?

The readOnlyHint: true annotation already covers the safety profile (this is a read operation). The description adds value by disclosing what the read returns, including the computed per-person balances and the shortest settlement payment set—useful behavioral context beyond the bare annotation. There's no contradiction. It doesn't disclose things like whether the split must exist or error behavior, but for a read tool with the annotation present, this is adequate.

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

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

One sentence, zero waste. It front-loads the verb ('Read'), specifies the resource, and enumerates the returned data compactly. Every element earns its place, and no filler or redundant phrasing exists.

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

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

For a single-parameter read tool with readOnlyHint annotation and an output schema present, the description is largely complete. It enumerates what the response includes (participants, expenses, balances, settlement set). Since the output schema exists, the description needn't detail the return structure further. Slight room to mention whether the key/link works for both input forms or if the split must exist, but it's otherwise thorough.

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%—the single 'split' parameter is documented in the schema as the split key or full link. The description doesn't add parameter-specific meaning beyond what the schema provides, but it doesn't need to since there's exactly one parameter with full coverage. The baseline of 3 for high schema coverage applies correctly here.

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

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

The description uses a specific verb ('Read') with a clear resource ('a split') and enumerates what's returned: participants, expenses, per-person balances, and settlement payments. This clearly distinguishes it from the sibling tools, all of which are mutation-oriented (add_expense, update_split, delete_entry, etc.), so there's no ambiguity about this being the read operation. While it doesn't name a sibling explicitly, the contrast with the write-heavy siblings is obvious.

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 as the retrieval tool for split details, and the sibling tools being all mutations makes the read-vs-write context clear. However, there's no explicit when-to-use or when-not-to-use guidance, nor mention of alternatives. It's a single-parameter, single-purpose tool, so heavy guidance isn't needed, but a note like 'use when you need to view balances or settlement calculations' would strengthen it.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the basic write/safety profile is covered. The description adds meaningful behavioral context: it works only on simple accountless splits, and secure splits are read-only (a key constraint). It does not elaborate on reversibility or other side effects, but for a payment-recording tool with annotations present, the added constraint context justifies a 4.

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, zero filler. It front-loads the core purpose, then the workflow hint, then the critical constraint. Every sentence earns its place with actionable 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 mutate-tool with full schema coverage, an output schema, and rich annotations, the description covers the essential points: what it does, the prerequisite workflow, the split-type constraint, and when it isn't applicable. The return value is handled by the output schema. Complex enough with 6 parameters, but schema + description together are 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?

Schema description coverage is 100%, so the baseline is 3. The description adds value by conveying the payment direction semantics ('who sent the money' vs 'who received it') and by clarifying the split types each field applies to. However, most parameter meaning is already well-documented in the schema's per-field descriptions, so the description's marginal parameter contribution is modest — a 4 reflects the useful direction-of-payment framing.

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

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

The description uses a specific verb+resource combination ('Record that one person paid another back, settling part or all of a debt') and clearly distinguishes from siblings by noting it works on simple, accountless splits while secure splits are read-only. It names a sibling ('get_split') to clarify workflow context.

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

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

Provides explicit when-to-use guidance: 'Use get_split first to see who should pay whom' explains the prerequisite workflow. It also gives explicit exclusions — secure splits are read-only here and must be opened in a browser — which prevents misuse on the wrong split type. This is exemplary usage guidance.

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

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

Annotations declare destructiveHint=true, and the description strongly reinforces this with 'Remove someone' and warns it only works if they aren't on any expense yet. The description adds valuable context about the constraints (read-only secure splits, simple/accountless split limitation) that go beyond what annotations provide. It doesn't contradict annotations; it complements them with important behavioral specifics.

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, all carrying meaningful information with no padding. The description is efficiently front-loaded with the core action ('Remove someone from a split') followed by constraints. 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 mutation tool with destructiveHint and readOnlyHint=false, the description covers the key constraints: the prerequisite (not on any expense), the split type limitation (simple/accountless), and secure split behavior. The output schema exists to describe return values, and the 2 params are fully documented in the schema. This is a complete picture 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 100% for both parameters (split and participant), each with clear descriptions. The description reinforces which objects are involved and the constraints (removal is restricted), but the schema already documents the parameter semantics well. The description adds the eligibility nuance for the participant parameter by stating the 'not on any expense' condition.

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

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

The description states a specific verb+resource ('Remove someone from a split') and immediately differentiates from siblings by noting it works only on accountless, simple splits and that secure splits are read-only here. This distinguishes remove_participant from similar mutation tools like rename_participant and add_participant.

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 clear usage context: 'Only works if they aren't on any expense yet' states a runtime precondition, and 'Secure splits... are read-only here and must be opened in a browser' explicitly tells the agent when NOT to use this tool. This is explicit when/when-not guidance with clear boundaries.

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=false and destructiveHint=false. The description adds crucial behavioral context: secure splits are read-only and will fail for this operation, and it clarifies the persistence model (name change on the split). This adds meaningful value 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?

Three concise sentences that are front-loaded with the core purpose and immediately followed by the critical limitation about secure splits. Zero wasted words — every sentence carries operational meaning.

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 straightforward rename operation with full schema coverage and an output schema, the description is nearly complete. It covers the operational constraint (secure splits fail), which is the main risk. The only minor gap is not stating what happens to the returned data, though the output schema covers that.

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 all three parameters have descriptions. The description adds context about the split parameter accepting either a key or a full link, and clarifies that participant can be a name or id. The description complements the schema well without redundancy.

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+resource (change a participant's name) and explicitly distinguishes between split types — simple accountless splits vs secure read-only splits. This differentiates it from siblings like add_participant and remove_participant by establishing the rename operation.

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 on when the tool works (simple, accountless splits) and specifically warns that secure splits must be opened in a browser. It doesn't explicitly name alternative tools but the constraints are well articulated.

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; description adds the key behavior that it replaces the entire current list (providing the empty-array-to-clear hint). It also discloses the secure-split read-only restriction, which is valuable operational context beyond annotations. Minor gap: doesn't mention whether changes are reversible or any confirmation/response behavior, but given existing annotations the bar is lower.

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 tight sentences, all earning their place. Front-loads the purpose, adds the replacement behavior, then the scope restriction. Zero filler or redundancy.

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

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

For a mutation tool with destructiveHint, the description thoroughly covers purpose, scope limits, and the critical empty-array-to-clear behavior. It notes the tools applies only to simple splits, which is essential for an agent choosing among 11 siblings. Output schema exists, so return format needs no explanation. Minor gap: doesn't mention maxItems=8 limit but that's captured in schema.

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

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

Schema already explains 'split', 'value', and 'participant' at 67% coverage. Description adds meaning beyond schema: clarifies methods array can be empty to clear, explains the replace-semantics, and connects methods to the broader purpose (QR code/pay link). The 'value' parameter's format is fully documented in schema, so little added here, but the array-replacement semantics is meaningful added value.

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

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

Description clearly states verb+resource+effect: 'Set how a participant wants to be paid back' and explicitly notes the consequence ('so the split can show a QR code or pay link'). Differentiates from siblings by specifying it works only on simple, accountless splits and that it replaces the current list.

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

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

Provides explicit when-to-use rationale (to enable QR code/pay link display), and clearly states exclusions: secure splits are read-only and must be opened in a browser. This effectively tells the agent when NOT to use this tool among sibling tools like record_payment or update_split.

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

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

Beyond the annotations (not read-only, not destructive), the description adds meaningful behavioral context: it states the partial-update behavior ('Only the fields you pass are changed'), which is a key behavioral trait not captured by annotations. It also discloses the read-only restriction on secure splits. The only gap is not describing response output, but an output schema exists so this is not required. Credit given for the partial-update and scope 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?

Three tight sentences covering purpose, behavior, and exclusions without fluff. Front-loaded with the core action. Every sentence earns its place; no redundancy with schema or annotations.

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 9-parameter mutation tool, the description covers the essentials: what it does, partial-update behavior, id sourcing, and the secure-split caveat. With an output schema present and 89% schema parameter coverage, the description adequately bridges the gaps. Could mention prerequisites like split ownership, but the secure-split caveat substantially covers the main restriction. Minor gap is not listing all editable fields, but schema handles that.

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 89% (high), so the schema itself documents parameters well. The description adds the partial-update semantics that clarify which parameters are optional overrides. It doesn't add per-parameter detail beyond what the schema provides (e.g., date format, shares semantics are already in schema). Baseline 3 is appropriate given the 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 clearly states the verb (change/update), the resource (existing expense or payment), and the scope (only fields passed are changed). It distinguishes from siblings by noting it works on simple, accountless splits, and explicitly frames it as the update counterpart to add_expense/record_payment and a companion to get_split. Strong purpose statement.

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

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

Explicitly states when to use: to modify an existing expense/payment. Provides critical exclusions: secure splits (created by signed-in user) are read-only here and must be opened in a browser, implying use of get_split or browser for those. Tells where ids come from (get_split). This is robust when/when-not guidance for a mutation tool.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false, but the description adds meaningful behavioral context: the currency lock once expenses exist, the read-only nature of secure splits, and the requirement to open those in a browser. These go beyond what the annotations convey and give the agent actionable constraints.

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, all carrying meaningful information: what can be changed, the currency lock constraint, and the secure-split exclusion. No filler or redundancy.

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

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

The description covers the essential constraints (currency lock, secure split exclusion) and the tool is straightforward with a clear output schema. It's reasonably complete for a mutation of title/currency, though it could note whether title is optional or what happens with partial updates.

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 (only the 'split' param is described), the description partially compensates by explaining that title and currency are the two changeable fields and noting the currency lock constraint. However, it doesn't elaborate on title constraints or currency format beyond the schema enum. Given the low coverage, it could add a bit more but the basics are 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?

Description clearly states the verb (change) and resource (a split's title or currency), and defines scope via the currency-locking constraint. It distinguishes from siblings by noting what kinds of splits it works on (simple, accountless) and which are excluded (secure 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?

Explicitly states when it works (simple, accountless splits) and when it doesn't (secure splits must be opened in a browser). The currency-locking note implicitly guides agents away from attempting currency changes after expenses exist. However, it doesn't name specific alternative sibling tools for the excluded cases.

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