lesgooo.fun

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

Annotations already declare readOnly=false, idempotent=false, destructive=false and openWorld=true, so the safety profile is covered. The description adds useful semantics beyond that: the checklist is 'shared' (visible to other plan participants) and it accepts exactly one item per call (non-batch). It still doesn't explain duplicate handling or what happens if the plan lacks a checklist.

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

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

Two sentences, zero waste, with the core action stated first and the usage condition second. Nothing is buried or repeated.

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 small mutation tool with no output schema, the description plus the fully documented schema covers what an agent needs: auth token provenance, plan reference format, and item granularity. Only edge cases like duplicate items or missing-checklist behavior are unaddressed.

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 all four parameters are already documented, including the plan-link format and the 500-char single-item constraint on text. The description reinforces the single-item rule for text but adds no new parameter guidance, so baseline 3 applies.

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

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

States a specific verb and resource ('Adds one item to the plan's shared checklist') and scopes the item types to task/ingredient/thing-to-bring, which helps separate it from add_expense or add_place. It doesn't explicitly name a sibling tool, but the resource boundary is clear enough to disambiguate.

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?

'Use when the user wants something added to the to-do or packing list' gives a concrete triggering condition tied to user intent. No explicit exclusions or named alternatives are offered, so it falls short of a 5.

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

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

Annotations already cover safety (readOnly=false, destructive=false, idempotent=false), so the description earns credit for what it adds: the non-monetary nature of the operation and the equal-split semantics with defaults for payer and sharers. It does not address retry/duplicate handling, which is a notable omission for a non-idempotent mutation.

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 filler: the first defines mechanics and defaults, the second states the use condition. Front-loaded and every clause carries 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?

Annotations cover safety and the rich schema covers all parameters, so the description only needs the conceptual model, which it supplies (equal split, no money movement, defaults). The one gap is what happens on a repeat call within 10 minutes, which the description leaves entirely to the schema.

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

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

Schema description coverage is 100%, so all nine parameters are already explained, including defaults, currency adoption rules, and allow_duplicate. The description's only addition is the equal-split rule, which is meaningful but small; 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?

States a specific verb and resource (records a shared expense) and immediately qualifies the split model ('split equally') plus the key fields involved. It also draws a hard boundary against the sibling record_payment by declaring 'It records the cost only and moves no money.'

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?

Gives a concrete trigger: 'Use when the user reports something they or someone in the group paid for.' Combined with 'moves no money,' this implies when-not-to-use (settling up), but it never names record_payment as the alternative, so routing requires inference.

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

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

Annotations already cover mutation, open-world behavior, idempotency and non-destructiveness. The description adds valuable workflow detail: the default search returns up to five unsaved candidates with status needs_selection, a second call with google_place_id saves official details/map link/photo, manual mode bypasses lookup, and duplicates are merged.

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, front-loaded with the core behavior and then the main branches (default search, save with google_place_id, manual mode, duplicate merging). Every sentence adds useful information with no padding.

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

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

For a 10-parameter open-world mutation with no output schema, the description explains what is returned during search, the needs_selection status, and what gets saved after selection. Remaining auth and parameter details are handled by the schema and annotations, so an agent has enough to call 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 the schema already documents all 10 parameters. The description reinforces the roles of google_place_id and source=manual, but does not add syntax or format details beyond the schema and leaves plan, participant_id, participant_token and query specifics to 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?

States a specific verb and resource ('Suggests a place') plus scope ('for the group to vote on (Where)') and the search-vs-save workflow. It does not explicitly name the sibling vote_place, so sibling differentiation is implied rather than stated.

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?

Gives a clear trigger ('Use when the user proposes a venue or destination') and explains when to use source=manual versus the default Google lookup. It does not state when not to use the tool or name vote_place as the alternative for voting.

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 this a non-read-only, idempotent, destructive, open-world mutation, so the safety profile is covered. The description's contribution is that the operation is bidirectional and reversible via done=false, which usefully softens the destructive framing. It says nothing about auth requirements (participant token) or what happens when item_id does not resolve to a valid text match.

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

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

Two sentences, no filler, and the state semantics are front-loaded before the usage hint. Every clause carries information an agent would otherwise have to guess.

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 five-required-parameter mutation whose plan/item_id/token semantics are spelled out in the schema, the description plus schema is enough to invoke correctly, and no output schema exists to need explaining. A brief note on what a failed item lookup does (the description hints the exact item text works via schema only) and on return behavior would close the remaining 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?

At 80% schema coverage the baseline is 3, and the description earns an extra point by giving semantics to the one parameter the schema leaves bare: done (type boolean, no description) is explained as done=true for finished and done=false for reopening. The other four parameters are fully documented in the schema itself.

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 ("Marks a checklist item done") and defines both directions of the toggle, which distinguishes it from the read-oriented get_checklist. It never names a sibling tool explicitly, so an agent must infer the boundary with add_checklist_item and get_checklist on its own.

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?

"Use when the user says a task is finished or needs reopening" gives a concrete trigger condition tied to user intent, which is exactly the signal an agent needs. There is no exclusion guidance (e.g. use get_checklist first to find the item_id), so it stops short of a full when/when-not statement.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=true, so the safety profile is partly covered. The description adds genuinely useful context beyond that: the return payload (shareable links plus private participant_id/participant_token), the fact that no invitations are sent, and that title/name are optional. The request_id replay semantics live in the schema rather than the description, leaving a small 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?

Five short sentences, zero padding, and the operation and participant scope are front-loaded ahead of the return-value and side-effect notes. Every 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?

No output schema exists, and the description compensates by naming the return values (shareable links, participant credentials) and flagging the side-effect absence. For a 3-param creation tool with annotations present, nothing critical is missing.

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

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

Schema coverage is 100%, so the schema already fully documents title, your_name, and request_id, including the UUID replay behavior. The description only reiterates that title and name are optional, adding little meaning beyond the structured fields. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('Creates a new saved lesgooo group plan') plus a distinguishing behavior ('with the user as its first participant'). This clearly separates it from siblings like get_plan, join_plan, and update_event without needing to open their schemas.

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

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

Provides a clear trigger condition: 'Use when the user wants to start planning something new.' The note that it 'sends no invitations or notifications' implicitly distinguishes it from join_plan and invite flows, but no sibling is named explicitly and no when-not guidance is given.

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/openWorldHint already declared by annotations, the description adds a genuine behavioral fact: non-exact input returns nothing and enumeration is out of scope. It does not describe the shape of a successful result, which matters since there is no 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?

Two short sentences, purpose front-loaded before the negative constraint. The second sentence is slightly redundant ('no results' / 'never enumerate') but earns its place as a hard guardrail.

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

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

For a one-parameter read-only tool the essentials are present, but with no output schema and thin parameter docs, an agent still doesn't know what a resolved mention looks like or what error/empty responses return.

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

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

Schema coverage is 0% and the single 'query' parameter has no description or format constraint in the schema. The description only loosely implies the accepted value ('link or exact ID'), leaving the 300-character bound and accepted link formats undocumented.

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 (resolve) and resource (a saved-plan link or exact ID), plus the consumer context ('desktop mention picker'). It does not name the sibling it supersedes (e.g., get_plan), so differentiation is inferred rather than explicit.

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?

Gives a clear when-to-use condition ('explicitly supplied ... link or exact ID') and a when-not ('empty or general searches return no results; never enumerate plans'). It doesn't point the agent to an alternative tool for general searches, which would have made this a 5.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so safety is covered. The description adds value beyond them by disclosing the return shape (open and done items, each with item_id), which matters since there is no output schema. Missing details are minor: nothing on behavior for an invalid or missing plan reference beyond what the schema says.

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 tight clauses: what it reads first, when to use it second. No filler, though the phrase "shared checklist" is slightly redundant with the return-contents clause.

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?

A single-parameter read tool with no output schema; the description compensates by naming the returned fields and the user intent that should trigger it. Nothing essential to correct invocation is missing.

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

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

Schema description coverage is 100% and the plan parameter already documents the accepted link format and the rejected draft-link case in detail. The description adds nothing about the parameter, 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?

States a specific verb and resource ("Reads the plan's shared checklist") and names the payload contents (open and done items with item_id), so an agent knows exactly what it returns. Sibling differentiation is only implicit — it never names check_item or get_plan — but the read-only framing makes the split from mutation siblings clear enough.

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 sentence "Use when the user asks what still needs doing or what is on the list" gives a concrete triggering condition. It offers no explicit exclusions or named alternatives (e.g. check_item for marking items done), so it stops short of the 5 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context by spelling out exactly what data is returned (balances and suggested settlement transfers, in the plan's currency), which matters since there is no 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?

Two sentences with no waste: the first front-loads the returned data, the second gives the usage trigger. 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 no output schema, the description carries the burden of explaining return contents and does so well. Only minor details (error behavior for invalid/unsaved plans) are left to the parameter 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% and the sole `plan` parameter is documented in detail, including the accepted link/ID formats and the rejection of unsaved drafts. The description adds nothing beyond the schema here, 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 names a specific verb (Reads) and resource (the plan's shared costs) and enumerates what is returned: expenses, payments, participant balances, and settlement transfers. This clearly separates it from write siblings like add_expense and record_payment.

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?

"Use when the user asks who paid what or who owes whom" gives a concrete trigger condition. It doesn't explicitly name alternative tools or state when not to use it, but the read-vs-write distinction against add_expense/record_payment is implied clearly.

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 readOnly/openWorld/non-destructive, so the safety profile is covered. The description adds genuinely new behavior: that `time_zone` is what resolves "today" and that `since` returns only changes after an earlier server_time, which is non-obvious delta semantics. It doesn't discuss pagination or read-budget truncation beyond the schema's include_all_dates note.

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?

Front-loaded with the verb+resource, then usage, then parameter semantics—a sensible order with no filler sentences. The first sentence is a long enumerative run-on, but each listed item carries information in the absence of an output schema.

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

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

With no output schema, the description correctly takes on the burden of describing return contents and does so thoroughly, plus it explains the delta and time-zone behaviors. Minor gap: it doesn't note result-size/truncation behavior, which is left to the include_all_dates schema text.

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 earns above baseline by explaining the functional role of two parameters—`time_zone` as the anchor for today's date and `since` as a delta cursor against a prior server_time—which the schema text alone only hints at.

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 ("Reads a saved plan") and then enumerates the payload (title, event details, participants, availability, RSVP, best dates, places with votes, currency), so an agent knows exactly what comes back. It does not explicitly differentiate itself from siblings like find_plan_mentions or open_planner, which keeps it below a 5.

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

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

"Use when the user shares a plan link or asks about a plan's current state" gives a concrete trigger condition. It also implies the incremental-refresh case via the `since` sentence. No explicit when-not conditions or named alternatives are provided.

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

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

Beyond the annotations, the description discloses important behavior: it returns private credentials, existing credentials rename the same participant, and it does not verify identity or grant organizer rights. Those are exactly the side effects and security limitations an agent needs before invoking a mutation tool with destructiveHint=true and openWorldHint=true.

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

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

The action is front-loaded in the first sentence, followed by usage guidance, the rename nuance, and the identity/organizer limitation. The four sentences are tight and each carries distinct information without repetition.

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

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

For a six-parameter mutation tool with full schema coverage and annotations but no output schema, the description covers the essential behavioral context: what it does, when to use it, that it returns private credentials, the rename behavior with existing credentials, and the lack of identity verification or organizer rights. Nothing an agent needs in order to call it correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents plan, name, selection, participant_id, participant_token, and existing_participant_id thoroughly. The description adds the useful nuance that existing credentials rename the participant, but it does not explain the selection enum or the distinction between participant_id and existing_participant_id, so it stays at the baseline for a fully documented schema.

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

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

The description states a specific verb and resource: it adds the user to a saved plan or selects an existing participant by name, and returns that person's private credentials. It also clarifies that existing credentials cause a rename rather than a new add, which distinguishes this action from create_plan and get_plan without relying on the schema.

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

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

It explicitly says to use this when the user wants to take part in an existing plan or act as a specific participant. That is clear usage context, but it does not name alternatives such as create_plan for missing plans or get_plan for read-only inspection, and it gives no explicit when-not guidance beyond the identity/organizer limitation.

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 readOnly annotation, the description adds useful behavior: opening saves nothing, and without a plan it shows an unsaved local draft. It does not describe participant-token requirements, but those are partly covered in the 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 front-loaded, compact, and every sentence contributes: purpose, optional targeting, draft behavior, no-save behavior, and usage trigger. There is no repetition or filler.

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

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

For a read-only interactive opener with no output schema, the description covers what the tool does, what happens with no plan, and when to use it. Minor gaps remain around participant-token coupling and exact return/UI behavior.

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

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

The description adds useful optionality context for plan, module, and participant selection. However, with only 50% schema description coverage, it does not fully compensate for the token-pairing requirements or module value mapping.

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: opens the interactive lesgooo planner in the conversation. It also names the planner modules and distinguishes the tool from plan-mutating siblings by emphasizing that opening saves nothing.

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 a clear usage condition: use when the user wants to see or edit the plan visually. It does not explicitly name alternatives such as get_plan or create_plan, but the intended 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?

With readOnlyHint=true, destructiveHint=false, and openWorldHint=false already declared, the description adds useful context: defaults and recent history stay on the device, and no shared plan is changed. That locality and scope information goes beyond the annotations, though it does not describe what 'open' returns or how the preferences view behaves.

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

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

Two short sentences, front-loaded with the action and followed by the locality and shared-plan constraint. Every phrase adds information and there is no redundant or filler 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?

For a zero-parameter, read-only tool with rich annotations and no output schema, the description gives enough context to invoke it correctly: it opens local widget preferences and does not touch shared plans. The only minor gap is that it does not specify whether opening returns data, launches a view, or exposes preferences in another form.

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 is no parameter semantics to document. The schema is empty and fully self-describing; baseline for a no-parameter tool is 4.

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

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

The description states a specific verb and resource: 'Open local widget preferences.' It also scopes the tool as local-device-only and clarifies that it does not affect a shared plan, which distinguishes it from shared-plan or settings-update siblings, though no sibling is named explicitly.

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

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

Usage is implied by 'Open local widget preferences' and the contrast with tools that change a shared plan. However, the description does not explicitly say when to choose this over read_plugin_settings or update_plugin_settings, so the guidance remains implicit rather than directive.

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, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds that preferences are device-local rather than account-scoped, which is genuinely useful context, but it does not describe the read behavior itself or what 'layout' means, and 'the action opens ... preferences' is ambiguous for a read tool.

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

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

Two short sentences with the purpose front-loaded and no filler. The second sentence earns its place only partially, since 'opens device-local preferences' muddies rather than sharpens the read semantics.

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?

An output schema exists, so return values need not be explained, and annotations cover the safety profile. What is missing is clarity on the core operation: 'settings layout' and the verb 'opens' leave ambiguity about whether this reads configuration data or launches a preferences surface.

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 takes zero parameters, so the baseline is 4. The description's note that there are no account settings adds scope meaning beyond the empty schema, though there is no parameter syntax to clarify.

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

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

The description states a specific verb+resource ('Read the plugin settings') and scopes it ('no account settings; device-local preferences'), which distinguishes it from the account-level siblings. However, 'settings layout' is vague, and it never names update_plugin_settings or open_preferences, so the boundary with those siblings is left implicit.

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 clarifies that there are no account settings, a negative scope statement, but gives no positive guidance on when to call this instead of update_plugin_settings, open_preferences, or open_planner. An agent gets no usage context or prerequisite information.

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, it clarifies that this is bookkeeping only and moves no money, which meaningfully reinforces destructiveHint=false and prevents an agent from assuming a transfer occurs. It does not discuss the duplicate/retry semantics that annotations flag via idempotentHint=false, leaving that to the 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 key constraint (already paid / no money moves) is front-loaded, and every clause contributes: the concept, the amount default, the completed-only restriction, and the trigger phrase. No filler or repetition.

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

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

For a mutating tool with annotations covering the safety profile and a fully documented schema, the description supplies the trigger condition and the no-money-moved guarantee. The only gap is that, with no output schema, it never hints at what is returned or how the recorded payment appears afterward.

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 every parameter is already documented. The description only restates the amount default ('defaults to what they owe that person'), paraphrasing the schema's 'suggested settle-up amount' without adding format or edge-case detail, 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 gives a specific verb and resource ('records that the participant has already paid someone back'), and the parenthetical 'settling up' makes the settlement concept unambiguous. It implicitly separates this from recording a new expense ('moves no money'), though it never names the sibling add_expense, so differentiation is inferred rather than explicit.

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?

'Use when the user says the money was actually sent' is a concrete, quotable trigger condition, and 'records a completed payment only' effectively states the negative case (not for planned or pending payments). It stops short of naming an alternative tool for the not-yet-sent case, which would have made this a 5.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so safety and repeat-call behavior are covered. The description adds a critical behavioral constraint not in the schema: only entries added by this participant can be removed. It does not describe error behavior for unauthorized/failed deletes, but adds meaningful context 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?

Two compact sentences, front-loaded with the action and supported resource types. The ownership exclusion and usage condition follow immediately, with no wasted 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?

For a destructive, no-output-schema tool, the definition covers supported kinds, the participant-ownership precondition, and the trigger condition. The schema handles authentication and identifier formats, so remaining gaps are minor.

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

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

Schema coverage is 80%, with detailed descriptions for plan, participant_id, participant_token, and id, plus an enum for kind. The description lists the same resource kinds as the enum but adds no syntax or format detail beyond what the schema provides, so baseline 3 is appropriate.

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

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

States a specific verb ('Deletes') and the exact resource kinds it handles: expense, payment, checklist item, or place. This clearly distinguishes it from sibling add_* and get_* 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?

Explicitly says to use it when the user asks to delete a specific entry, e.g. to correct a mistake. It also states a key exclusion: entries added by others cannot be removed. It does not name update_* or get_* siblings as alternatives, but the use condition 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 already flag destructive=true and idempotent=true, so the description's real contribution is the mode semantics: add merges, remove subtracts, replace overwrites. That tells the agent which calls can wipe prior availability, which is the key risk context. It stops short of saying replace discards all existing windows and entries.

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, front-loaded with what changes, then mode semantics, then when to use it and what it is not. Every clause carries distinct information with no repetition of the title.

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 mutation with no output schema, this covers payload shape, mode behavior, use trigger, and sibling exclusions; the schema already documents formats, limits, and credential sources. An agent can invoke it correctly from this definition plus the schema.

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

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

Schema description coverage is already 86%, so the baseline is a 3; the description earns the extra point by tying parameters together into one model (all-day dates plus exact windows that must be ISO with offset and a matching IANA time_zone). The mode definitions largely restate what the schema's mode enum description already says.

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 (changes) and resource (one participant's availability) with the exact payload shape: all-day dates and/or ISO free-time windows plus IANA time zone. It explicitly excludes the two most confusable siblings, the agreed Event date (update_event) and RSVP (set_rsvp), so an agent can route without opening either schema.

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

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

"Use when the user says which days or hours they are or are no longer free" is a clear positive trigger, and "It does not set the agreed Event date or an RSVP" names the nearest competing actions. It does not spell out prerequisites (a saved plan plus participant_id/token), though the schema requires them.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false; the description adds the missing piece by explaining that "clear" removes the existing answer, which is what the destructive flag refers to. It also discloses the occurrence scoping default (next occurrence), though it says nothing about authorization/participant_token requirements or overwriting an existing answer.

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

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

Three short sentences, zero filler, with the core action and status values front-loaded and the repeating-event nuance and usage trigger following in order of need.

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 five-parameter mutation with no output schema, the description covers what the tool does, the value space, the default occurrence behavior, and the compile-time trigger, and the schema itself handles plan-link validity and credential sourcing. Nothing essential for a correct call is missing.

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

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

Schema coverage is 80%, so the schema baseline carries most parameters, but the description still adds meaning: it explains the semantics of the three status values and that occurrence_date defaults to the next occurrence, a default the schema does not state. That is genuine added value over the enum and pattern constraints.

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

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

States a specific verb and resource: recording the participant's RSVP (yes/no/clear) on the plan's Event. That wording conceptually separates it from scheduling-flavored siblings like set_availability, but no sibling is ever named, so differentiation is left implicit.

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?

Gives a clear trigger: "Use when the user says they are or are not attending." It supplies no exclusions or alternatives (e.g., when to use set_availability instead), so the agent gets context but not routing help.

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?

Adds meaningful behavior beyond annotations: omitted fields stay unchanged, empty strings clear fields, and start_time omitted means all-day. These are useful mutation semantics even though annotations already declare destructive and idempotent behavior.

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

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

Front-loads the core action and affected fields, then adds precise mutation semantics in a compact form. Every clause conveys actionable information with no waste.

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

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

For a 10-parameter mutation tool with no output schema, the description covers update behavior, omission semantics, clearing behavior, and time handling. It could say more about authentication or irreversible effects, but annotations already flag destructiveness.

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 70%, and the description adds important semantics not fully captured in the schema, including local-time handling, all-day behavior when start_time is absent, and empty-string clearing. It does not explain every field, but it meaningfully supplements 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?

States a specific verb and resource: updates shared Event details, and explicitly lists the affected fields (title, date/time, location, description). It is clearly distinguishable from sibling tools like set_availability, set_rsvp, or add_place.

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?

Gives a clear usage condition: use when the user sets or changes agreed event details or renames the plan. It does not name alternatives or exclusions, but the context is sufficient for correct 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?

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description genuinely adds beyond that by disclosing that an update is a no-op and that no settings are settable, which prevents a wasted or harmful call. It stops short of explaining why the tool is exposed at all.

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

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

Three short sentences with the constraining fact front-loaded, which is efficient. Two of the sentences restate the same point (nothing is settable / empty update does nothing) and the widget reference sits last, so there is minor redundancy rather than tight single-purpose messaging.

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?

An output schema exists, so return values need not be described, and the description does cover the no-op nature of the tool. Given a required nested parameter, 0% schema coverage, and a name implying mutation, it still leaves unclear what an agent should do if it does call this tool and whether a non-empty 'set' is ever valid.

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 'set' parameter has 0% schema description coverage, so the description must carry the load. It only obliquely explains the parameter via 'an empty update is a no-op', without saying that 'set' must be an empty object or listing any permitted keys, leaving the agent to reverse-engineer the schema's additionalProperties: false constraint.

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 defines the tool almost entirely by negation: it says no primitive account settings are available and that an empty update is a no-op, but never states what update_plugin_settings actually does or why it exists. The only positive information is a routing hint ('device preferences are changed in the widget'), which is more about a sibling than this tool.

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 implies the tool should effectively never be invoked ('an empty update is a no-op') and points to the widget for device preferences, which is a partial alternative-routing hint. However, there is no explicit 'use this when / do not use this when' statement, and the implied 'don't call me' guidance is left for the agent to infer.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is largely covered. The description adds that a vote can be cleared (explaining the destructive hint) but says nothing about the required participant identity/token, per-participant scoping, or what state results after voting. With annotations carrying most of the burden, a 3 is appropriate.

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

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

Two sentences, zero filler: the operation and its three modes come first, the invocation trigger second. Nothing is repeated from the 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 five-required-parameter mutation with full annotation coverage and no output schema, the description covers what the tool does and when to call it. It could note that the participant token scopes the vote (so the agent knows whose vote changes), but no critical information is missing.

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

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

Schema coverage is 80%, so most parameters are documented structurally, and the enum for `vote` has no inline description. The description compensates by spelling out the three vote modes (up, down, clear), which is the key semantic the schema leaves implicit. It adds no detail on plan/participant parameters beyond what the schema already says.

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 specific verbs (up-vote, down-vote, clear) and the exact resource (a participant's vote on a suggested place), which is clearly distinct from siblings like add_place or remove_entry. It does not explicitly contrast with any sibling, so it falls just short of a 5.

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

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

"Use when the user expresses a preference for or against a place in the plan" gives a concrete trigger condition tied to user intent. There is no when-not guidance or named alternative (e.g., remove_entry for deleting a place), but the positive trigger 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?

The annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful operational context—app-only, backend-managed feature flags/counters/timeouts, and no paid API call from the browser—but remains vague about permissions, rate limits, or per-service behavior.

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

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

The description is short and front-loads the domain, but the second sentence ('The backend retains feature flags, monthly provider counters and timeouts') is implementation detail that does not clearly help an agent invoke the tool.

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

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

With no output schema, a nested payload object, and zero schema description coverage, the description should explain how to construct payloads per service. It does not, leaving the agent unable to call the tool correctly beyond guessing payload structure.

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

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

Schema description coverage is 0%, and the payload is a nested object with no documented shape. The description hints at three of the four enum services (autocomplete/details/link preview) but says nothing about payload fields or how each service expects them.

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

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

The description identifies the domain as Places search/details and link previews, which aligns with the service enum. However, it never states a clear verb or the overall purpose of widget_lookup, and does not differentiate it from siblings like add_place or vote_place.

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?

There is no guidance on when to use this tool versus add_place, vote_place, or other place-related siblings. The description also gives no indication of how to choose among the four service values.

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, destructiveHint=false and openWorldHint=true; the description adds the useful clarification 'Does not change schedule data', which tells the agent the scope of side effects is limited. However, 'bind' implies persisted state and the description never explains what is written where, who is authorized, or what happens on repeat calls, so it goes only slightly past 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 short, front-loaded sentences with no filler. Each carries a distinct fact (app-only, precondition, side-effect scope), though the phrasing is clipped enough to be cryptic.

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 two required, fully undocumented parameters, an open-world hint, and no output schema, the description leaves too much unspecified: it does not say what a plan is, what the call returns, or what happens if participant_id is unknown. The safety scope note helps, but the call cannot be made confidently from this text plus the schema.

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

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

Schema description coverage is 0% and both parameters (plan, participant_id) are required but undocumented. The description only alludes to a 'name' being selected and never explains what a plan identifier is or how participant_id relates to the selected name, so it fails to compensate for the coverage gap.

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

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

The description names the resource ('identity picker', 'the name explicitly selected') and scopes it as app-only, so the general intent is graspable. But it is phrased as a noun phrase plus the vague verb 'bind', so it never states concretely what operation is performed on the participant, and it does not differentiate itself from the sibling widget_lookup/widget_write 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?

'App-only' and 'the name explicitly selected in the shared web UI' imply a precondition: call this only in the app after a name was picked in the web UI. There is no explicit when-not guidance, no mention of widget_lookup or widget_write as alternatives, and no statement about what to do if no selection exists.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, and openWorldHint=true. The description adds useful context by stating it is app-only, reuses the web write gateway, has validation and budgets, and requires the selected participant token. It still does not explain what is destroyed, whether edits are reversible, or what the payload operations do.

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

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

The description is short and front-loads the app-only transport context, then adds gateway reuse and token requirements without repetition. Some phrases are opaque, but the structure is efficient and no sentence is pure 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?

This is a destructive write tool with a nested payload object, 7 largely undocumented parameters, and no output schema. The description provides some operational context, but it is not complete enough for an agent to safely determine how to invoke it or what the payload should contain.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate but only hints at participant_token. Critical required parameters like operation and payload are unexplained, as are plan, participant_id, and the target participant fields.

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

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

The description indicates a write/transport tool for shared web components and mentions saved-plan edits, so the general purpose is inferable. However, it does not specify the concrete operations or payload effects, and it does not distinguish this tool from siblings such as widget_lookup, widget_select_participant, or planner mutation tools.

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

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

The phrase 'for saved-plan edits' implies a usage context, and the token requirement gives a prerequisite. But there is no explicit guidance on when to use this versus widget_lookup, widget_select_participant, or other planner write tools, nor any 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.