TraydStar

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

Goes beyond the destructiveHint annotation by disclosing that the action is irreversible ('cannot be undone'), that it commits both sides by creating a Handshake, and that user confirmation is required before execution. That is exactly the behavioral context a mutation tool needs.

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

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

Four short sentences, front-loaded with the situation that triggers the tool, then the consequence, the safety prerequisite, and the return value. No filler; every sentence earns its place.

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

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

For a one-parameter destructive mutation with an output schema, the description covers timing, irreversibility, required confirmation, and the follow-up step ('what is needed next'). Nothing essential 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% and the single proposal_id parameter is already fully documented in the schema. The description adds no format or selection guidance beyond what structured data provides, so the baseline 3 applies.

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

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

States a specific verb+resource ('accept a trade proposal') and the concrete effect ('creating a Handshake'), which distinguishes it from siblings like decline_proposal, counter_proposal and withdraw_proposal. An agent can identify what this does without opening 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?

Gives a clear trigger condition ('when the user decides to accept a trade proposal they received') and a prerequisite ('Confirm with the user first'). It does not explicitly name alternatives (counter_proposal, decline_proposal) or state when-not-to-use, so it stops short of the top tier.

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 destructiveHint=true already declared, the description still adds meaningful context: the trade only becomes final once both sides mark complete, the action cannot be undone, and user confirmation is required. That is real value beyond the annotation, though it does not cover error or validation 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?

Three tightly packed sentences with no filler: the trigger, the irreversibility warning and confirmation requirement, then the scope exclusion. The most decision-relevant information (when to use it) is front-loaded.

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

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

Annotations carry the safety profile, an output schema exists so return values need no explanation, and the description covers trigger, irreversibility, confirmation, and a scope exclusion. Nothing an agent needs to invoke this 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?

There is a single parameter with 100% schema description coverage and a strict UUID pattern, so the schema fully documents it. The description adds no format, sourcing, or lookup guidance beyond what the schema already provides, which is the expected baseline.

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

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

The description states a specific verb and resource ('mark my side of a trade complete' / 'their side of an active Handshake is done') and scopes it to a post-exchange moment. It is clear on its own, but it never differentiates itself from similarly named siblings such as confirm_handshake or verify_handshake_payment, which an agent could plausibly confuse it with.

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 trigger condition is explicit: use it after the real-world exchange has happened and the user says their side is done, and confirm with the user first. It also carves out a when-not ('reviews are left on the website, not through this tool'), but it does not name alternative tools for adjacent actions, so there is no explicit routing guidance.

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

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

Annotations declare destructiveHint=true, and the description adds substantial context beyond that: no money moves, the trade only activates once both sides confirm, confirmation is irreversible, and the error path leaves state unchanged. This is exactly the kind of behavioral information annotations cannot 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?

Four tight sentences, front-loaded with the trigger condition, then consequences, then the caution, then the failure mode. Every sentence earns its place with no redundancy.

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

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

For a destructive mutation with an output schema, the description covers the trigger, the effects, irreversibility, and the error path. Return values need not be explained given the output schema, so nothing essential 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?

Only one parameter with 100% schema description coverage, so the schema already carries its meaning. The description adds no syntax or format details for handshake_id, 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?

States a specific verb (confirm) and resource (the user's side of a Handshake) with scope, and implicitly distinguishes itself from get_handshake (the read used to check preconditions) and complete_handshake. An agent can identify what this does without opening 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?

Gives an explicit precondition (use when get_handshake reports payment.state = 'covered'), an explicit exclusion (if a fee is owed, it errors and changes nothing), and names the sibling to consult. Nothing is left to inference.

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

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

Annotations already flag destructiveHint=true and openWorldHint=true; the description earns credit by explaining what gets destroyed ('the original proposal closes') and the follow-on lifecycle ('the counter goes to the other side as a new proposal they can accept, counter again, or decline'). This is meaningful context beyond the annotations, though it doesn't cover reversibility or authorization requirements.

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

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

Front-loads usage guidance, then parameter semantics, then behavioral consequence, ending with a guardrail. Four sentences, each carrying distinct and non-redundant 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?

With an output schema present, return values need no explanation, and the annotations cover the safety profile. Combined with clear when-to-use, parameter defaults, and lifecycle effects, the definition gives an agent everything needed 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 coverage is 100%, so the baseline is 3, but the description adds genuine meaning by explaining what offer_listing_id and want_listing_id change and their default behavior ('defaults to the listing that was asked for' / 'defaults to what was offered'). That default semantics is not captured by the schema descriptions.

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

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

States a specific verb and resource: answering a received proposal with different terms. It also explicitly distinguishes itself from the siblings accept_proposal and decline_proposal by contrasting the action ('instead of accepting or declining it'). An agent can identify this tool without opening any 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?

Gives an explicit trigger condition ('when the user wants to answer a received proposal with different terms') and names the alternatives it replaces (accept/decline). It adds a procedural guardrail, 'Confirm the terms with the user first,' which further constrains correct invocation.

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 and openWorldHint=true, so the write/external nature is known. The description adds genuinely new context: the listing becomes publicly visible, it returns an id, and photos cannot be attached through this tool (a real capability limit the agent must relay). It does not discuss auth, rate limits, or moderation side effects.

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

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

Three sentences, front-loaded with the trigger condition, then the effect, then the constraint, then the pre-call check. No sentence is redundant and nothing is buried.

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 14-parameter creation tool with a full output schema, the description covers the public-visibility implication, the photo limitation, and the required user confirmation. It leaves the draft/set_listing_status workflow entirely to the schema, which is acceptable, but a brief note on it would have made the definition airtight.

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 enums are documented, so the schema already carries all parameter meaning. The description only nudges the agent to confirm three of the four required fields (title, description, category) and omits required 'type', adding workflow flavor rather than semantic depth, which lands at the baseline.

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

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

The description names a specific verb and resource ('Publishes a public listing on their account') and states the outcome ('returns its id'). It is clearly distinguishable from siblings like update_listing, create_proposal, or save_listing, which do different things to the same domain objects.

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 trigger ('Use this when the user wants to offer a good or service for barter on TraydStar') plus a pre-call workflow instruction ('Confirm the title, description, and category with the user before calling'). However, it never names an alternative for the adjacent cases (e.g., use update_listing to edit, set_listing_status to publish a draft), so routing is only partially covered.

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

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

Annotations already establish it is a write operation (readOnlyHint=false) that is non-destructive and open-world. The description adds real behavioral context beyond that: the proposal is sent to the listing's owner, who is notified by email, and a pending proposal can later be withdrawn.

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 tight sentences with no filler; the triggering condition is front-loaded, followed by side effects, the confirmation prerequisite, and the follow-up action. Every sentence earns its place.

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

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

An output schema exists, so return values need not be explained. The description covers trigger, side effects, required user confirmation, and the withdrawal path, leaving nothing an agent needs 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 each parameter is already documented, and the description's note that offering one's own listing is optional only restates what the schema's required list shows. No additional syntax or constraint detail is provided beyond the schema.

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

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

States a specific verb and resource ('propose a barter trade for someone else's listing') plus the optional exchange of the user's own listing. This clearly distinguishes it from siblings like counter_proposal, accept_proposal, and create_listing.

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 when to use it ('when the user wants to propose a barter trade'), adds a prerequisite ('Confirm with the user which listing... before calling'), and routes to the alternative 'withdraw_proposal' for pending proposals. When/alternatives are both covered.

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 readOnlyHint=false; the description adds genuinely useful behavioral context beyond them — the proposal is permanently closed, cannot be reopened, and the counterparty must send a new one. It does not mention auth requirements or rate limits, but the irreversibility disclosure is the key trait for this 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?

Three short sentences with zero filler: trigger first, consequence second, safety directive last. Every sentence earns its place.

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

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

For a one-parameter destructive mutation with an output schema present, the description covers trigger, irreversibility, and confirmation, which is nearly everything an agent needs. Return-value behavior is correctly left to the 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?

Only one parameter (proposal_id) and schema description coverage is 100%, so the schema already carries the semantic load. The description adds no format or sourcing detail about the identifier, 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 ('turn down a trade proposal they received') and clarifies the actor relationship by noting the proposal was received, which separates it from create/counter actions. It never names a sibling such as withdraw_proposal or accept_proposal, so differentiation is implied 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 trigger ('when the user decides to turn down a trade proposal') and a precondition ('Confirm with the user first'). No exclusions or named alternatives (e.g., counter_proposal as the softer option) are offered, so it stops short of full routing guidance.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=false), so the bar is lower, and the description still adds a full state machine that annotations cannot express. It discloses that payment instructions may be embedded in the result, that a wallet link is a one-time prerequisite, and that exact-amount sending is required before verification.

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

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

A single dense sentence pair that is well front-loaded: purpose first, then the tri-state enumeration in the order an agent will branch on. Every clause carries actionable content, though the long parenthetical for 'payable' slightly compresses readability.

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 enumerated, yet the description still explains the one result field that drives behavior (payment.state) and the downstream calls for each value. Nothing an agent needs to invoke this tool and act on its result 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?

There is only one parameter and the schema already documents it at 100% coverage with a UUID pattern, so the baseline would be 3-4. The description adds only the gloss that a handshake_id refers to an agreed trade, which is minor added 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 gives a specific verb and resource ('check one Handshake') and defines the domain term ('an agreed trade'), immediately separating it from the sibling list_handshakes. It also states the scope of what is returned ('what your side still needs to do'), so an agent knows this is a single-item status lookup rather than a listing.

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 routes the agent explicitly by state: 'covered' means call confirm_handshake, 'payable' means link_wallet then send then verify_handshake_payment, 'settled' means no action. This is exactly when-to-use-which-alternative guidance tied to a concrete decision variable, with no inference required.

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 fully covered. The description adds workflow context (a pre-step to messaging or proposing) and reinforces the 'in full' read semantics, but says nothing about authorization, rate limits, or behavior when a listing is missing or removed. With annotations carrying the bulk, 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?

A single front-loaded sentence with no filler: action, condition, and follow-on use are all present. Every clause earns its place.

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

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

For a one-parameter read tool with an output schema and read-only annotations, the definition covers purpose, input source, and workflow placement adequately. The only gap is unstated behavior for invalid, missing, or non-visible listing ids, which is minor given the 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% (listing_id with format and pattern fully documented), so the schema already carries the parameter burden and the baseline is 3. The description only reinforces that the id is a known identifier sourced from search_listings; it adds no format or validation detail beyond the schema.

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

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

States a specific verb and resource ('read one TraydStar listing in full') and pins the input ('when you already have its id'). It implicitly differentiates itself from search_listings by naming that tool as the source of the id, so an agent can tell retrieval-by-id apart from search 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?

Explicitly says when to use it ('when you already have its id'), where the id comes from ('for example from search_listings'), and what it is a prerequisite for ('before messaging its owner or proposing a trade'). The conditional on having the id effectively excludes the discovery case in favor of the named sibling.

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 useful behavioral context about the opaque id's uniqueness and stability across token refresh, reconnection, and display-metadata changes.

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

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

Two sentences, front-loaded with the core action, with no wasted words. The second sentence earns its place by describing the stable opaque id.

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

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

The tool is a simple authenticated read with an output schema and full annotation coverage. The description supplies the necessary scope and identity-stability context without needing to restate return fields already defined in the 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?

The tool takes zero parameters, so there is no parameter semantics to document. The baseline for a parameterless tool is 4, and the description appropriately adds no irrelevant parameter details.

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 (Return) and resource (TraydStar profile), and clarifies that the profile is tied to the request's authenticated credentials. It does not explicitly contrast with sibling tools like get_handshake or get_listing, so it is clear but lacks sibling differentiation.

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

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

No when-to-use guidance is given. The description does not explain when an agent should call get_profile versus other read tools, nor does it mention any prerequisites or alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds real behavioral context beyond that: the return is a signable message requiring personal_sign, the linked address is returned "if any," and fee crediting depends on the linked wallet. Return format details are left to the 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?

Three tight sentences with the usage trigger front-loaded, followed by return contents and the crediting caveat. Every sentence carries distinct, 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 zero-parameter read tool with an output schema, the description covers when to call it, what it yields, and why it matters (fee crediting). Since the output schema documents the return structure, nothing essential 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?

The tool takes zero parameters and the schema is fully documented, so there are no parameter semantics to explain. The description correctly implies a no-argument call, making baseline 4 appropriate.

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

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

The description states a specific verb and resource: it returns the message to sign (EIP-191 personal_sign) and the currently linked address. It situates the tool in the payment flow, which helps separate it from sibling mutators like link_wallet and verify_handshake_payment, though it never names those alternatives directly.

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 this before paying a Handshake fee in USDC for the first time" gives a clear triggering condition. The note that fee payments are only credited from the linked wallet implies the follow-up action when no address is linked, but the alternative tool (link_wallet) is not explicitly named.

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 readOnlyHint=false, but the description adds concrete behavioral details: it replaces any previously linked wallet and the message expires after a few minutes. These details go beyond the annotations and are important for correct invocation.

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 the primary action and prerequisite. Every sentence adds useful context, and there is no filler.

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

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

An output schema exists, so return values need not be described. With full parameter coverage in the schema and annotations covering the mutation safety profile, the description provides the remaining workflow, replacement behavior, and expiry constraint.

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 each parameter, including the pattern and EIP-191 signature format. The description only loosely ties the message and signature to get_wallet_link_message, offering little beyond what the schema provides.

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

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

States a specific verb and resource: link the wallet that will pay Handshake fees. It clearly distinguishes itself from the sibling get_wallet_link_message by describing the action of submitting a signature rather than generating the message.

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?

Names the prerequisite action through get_wallet_link_message and explains the signature submission flow. It does not explicitly state when not to use the tool or list alternative linking methods, but the context is clear.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, establishing the safety profile. The description's added detail (latest message, unread counts) is return-content information that the output schema already covers, so it adds little genuine behavioral context 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?

A single sentence that front-loads the action and resource, then states exactly what each returned item contains. 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?

With an output schema present and zero parameters, the description needn't explain return values or inputs, and it covers the essential purpose plus a summary of what's returned. It is close to complete for such a simple read tool; only the routing to sibling read tools is unstated.

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 takes zero parameters and the schema is fully described, so there is nothing for the description to clarify about inputs. Baseline of 4 applies for a parameterless tool.

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

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

The description states a clear resource (conversations) and scope (who the user has been messaging, latest message, unread count), so an agent can distinguish it from read_conversation and mark_conversation_read by implication. It doesn't explicitly name those siblings, but the listing nature is unambiguous.

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

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

The phrasing 'Use this to see...' implies the usage context (surveying ongoing conversations) but gives no explicit when-not guidance or named alternative such as read_conversation. Adequate but leaves routing to inference.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=false), so the description is not the only source of behavior. It adds genuine semantic context by explaining what a Handshake represents and what its status fields indicate, but says nothing about scope, ordering, or volume of results.

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 zero padding, and the purpose is front-loaded before the definition. The definition sentence earns its place by disambiguating a non-obvious domain term the agent will encounter in the output.

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 with zero inputs there is little call complexity to cover. The domain-term definition makes the output interpretable. Minor gap: nothing states that results cover all of the user's handshakes or how they are ordered.

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 takes zero parameters and schema coverage is 100%, so per the baseline this scores 4. The description correctly implies no filtering input is needed, though not explicitly noting the absence of pagination or filter options.

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 clear verb (list/see) and resource (Handshakes) and even defines the domain term: an agreed trade showing confirmation and completion status on each side. However, it never distinguishes itself from the sibling get_handshake, which an agent must choose between when a handshake ID is known.

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 this to see the user's Handshakes" restates the purpose rather than giving guidance. There is no when-to-use vs get_handshake, no note that it requires a connected/authenticated user, and no exclusions or alternatives named.

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 genuine scope context beyond that — it returns both active and already-traded listings — which an agent cannot infer from annotations.

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

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

Two sentences, zero filler, front-loaded with the core purpose before the usage examples. Every clause earns its place by either identifying the resource or guiding invocation.

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 structure need not be described, and annotations carry the safety profile. The description covers purpose, scope of results, and intended use, leaving nothing an agent needs 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?

The tool takes zero parameters, so there is nothing the description needs to disambiguate; baseline for a no-param tool is 4. Schema coverage is 100% and no argument syntax needs explaining.

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?

Specific verb+resource (see the user's own TraydStar listings and their ids) with an explicit ownership scope that separates it from search_listings and get_listing. An agent can distinguish it from list_saved_listings and other list_* siblings immediately.

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 concrete when-to-use contexts: choosing a listing to offer in a proposal, and before editing or removing one. It does not name the alternative tools (e.g., get_listing for a known id) or state when not to use it, so it stops 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 declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description goes beyond that by enumerating the per-item signal the agent will see (status values PENDING/ACCEPTED/DECLINED/WITHDRAWN, direction sent/received, counterparty, offered and wanted listings), which is genuinely useful framing despite an output schema existing.

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

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

Two sentences, front-loaded with the purpose, with no preamble or filler. The second sentence is a field enumeration that partially overlaps the output schema, but it stays compact and readable.

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 list tool with a covering output schema and safety annotations, the description supplies everything needed to select and call it correctly. Nothing an agent requires 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?

The tool takes zero parameters, so there is no parameter semantics to add; the baseline for a parameterless tool is 4. The description correctly does not invent filtering options that the schema does not support.

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 ('see the trade proposals the user has sent and received') and delimits scope to the user's own proposals. It is clear what the tool returns, but it never names or contrasts a sibling (e.g., list_handshakes or get_listing), so differentiation is left to inference.

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 opener 'Use this to see...' implies the invocation context, and the scope ('sent and received') implies it is a personal, unfiltered listing. There is no explicit when-to-use vs. when-not guidance and no pointer to alternatives for narrower views.

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 safety is covered. The description adds one genuinely useful behavioral detail the annotations lack – results are returned newest first – but says nothing about pagination, result size, or empty-state handling.

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, no filler, and the key scoping word ('saved') plus the ordering arrive immediately. Nothing could be trimmed without losing 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?

With an output schema present, return-field explanation is unnecessary, and annotations carry the safety profile; the description supplies the ordering. The only open question left is whether the result set is paginated or capped, which for a no-parameter list tool is a minor gap.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. The baseline for a no-parameter schema 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?

States a specific verb (see/list) and a distinct resource (the listings the user saved), plus the sort order. It is distinguishable from list_my_listings and search_listings by the word 'saved', though it never names those siblings to sharpen the contrast.

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 this to see...' implies the situation, but there is no explicit when-not and no named alternatives such as save_listing, list_my_listings, or search_listings. An agent can infer the context but gets no 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?

Annotations already declare the mutation profile (readOnlyHint=false, destructiveHint=false, openWorldHint=false), so the description's job is lighter. It adds a useful scope constraint — only the read status of messages the user received is touched — but says nothing about idempotency, permissions, or whether the other member is notified. Additive but thin.

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 zero filler; the usage trigger is front-loaded and the scope caveat follows. Nothing to cut.

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 no explanation, and the tool is simple with one parameter. The description covers when and what scope it changes, leaving only minor gaps (idempotency, permissions) for what is a low-risk state update.

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 there is a single required parameter, so the baseline is 3. The description adds no meaning beyond the schema and notably does not clarify the slightly counterintuitive user_id semantics ('the other member in the conversation'), which help with correct invocation.

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

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

States a specific verb and resource: it clears the unread count of a conversation and explicitly scopes the change to messages the user received. That is enough to distinguish it from a fetch-style sibling like read_conversation, but it never names that sibling or spells out the difference, so the agent must infer it.

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 it after the user has seen the messages in a conversation. That is a clear when-to-use condition, but there is no counter-guidance (e.g. don't call it if messages are unread, or when to prefer read_conversation instead).

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 establish write/non-destructive/open-world, and the description adds genuinely new behavioral facts on top: the side effect is an outbound email to the counterparty, it fires only once, and it is rate-limited to one per 24 hours. That cooldown is exactly the kind of operational detail annotations cannot express.

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 zero filler, and the usage condition is front-loaded ahead of the side-effect and rate-limit details. Every clause carries 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?

With an output schema present, return values need not be described, and the description covers the trigger, the action, and the throttle. It omits edge cases such as behavior when the handshake is already complete or the counterparty cannot be reached, which would be the only 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?

Only one parameter, handshake_id, and schema coverage is 100%, with the schema already describing it as 'The Handshake the user is waiting on'. The description adds no format or validity guidance beyond what the schema states, 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 states a concrete action ('Emails them once') aimed at the counterparty of a Handshake, so the agent can tell this is an email-reminder tool rather than an in-app messaging tool like send_message. It is slightly indirect in that the verb 'nudge' carries the meaning only via the second clause, and it never names an alternative sibling to contrast with.

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 an explicit triggering condition: the user has completed their side of the Handshake and the counterparty has not. The 24-hour reuse constraint is stated. There is no explicit 'do not use when' or named alternative (e.g., send_message for other communication), which keeps it below 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 and destructiveHint=false, so safety is covered. The description adds genuinely non-obvious behavior beyond that: reading does not clear unread state, and only mark_conversation_read does. It does not discuss truncation/pagination limits when `limit` cuts off results.

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 with no filler; the core action comes first, the unread-state caveat second, and the pagination tip last. Every sentence carries information an agent needs.

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 annotations cover the safety profile. The description covers the non-obvious unread semantics and the cursor pattern. A minor gap remains around how 'oldest first' interacts with the schema's 'default 100, newest' limit behavior.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real semantic value for `after` — clarifying it should be the created_at of the last message already seen, i.e. a cursor rather than an arbitrary filter. `limit` is left to the schema, which is acceptable given full 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?

States a specific verb and resource ('read the messages between the user and one other TraydStar member') plus the ordering ('oldest first'), which is enough to separate it from list_conversations (many conversations) and send_message (writes). No ambiguity about what is returned.

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 concrete usage direction for incremental fetching ('Pass `after` ... to get only newer messages') and implicitly routes the agent to mark_conversation_read for the read-state change. It stops short of explicitly stating when not to use it or naming sibling alternatives like list_conversations.

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

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

Annotations already mark this destructive and not read-only, and the description substantially enriches that: it disappears from search, pending proposals are closed, the action is irreversible, the agent must confirm first, and in-progress trades block removal. These are concrete side effects and preconditions the annotations cannot express.

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 short sentences, each carrying distinct information (when to use, side effects, irreversibility + confirmation, precondition), and the purpose is front-loaded in the first 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?

With an output schema present and 100% schema coverage on the single parameter, the description only needs to carry behavior and preconditions, which it does fully: side effects, irreversibility, confirmation requirement, and the blocking condition. Nothing an agent needs to call this safely 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?

There is a single parameter whose schema description coverage is 100%, so the UUID format and meaning are already fully documented by the schema. The description only implicitly adds the ownership constraint via 'their own listings', which is the baseline expectation when the schema does the heavy lifting.

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

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

The description states a specific verb and resource ('take one of their own listings off TraydStar') and adds the ownership scoping constraint. It does not explicitly distinguish itself from semantically close siblings like set_listing_status, update_listing, or withdraw_handshake, so it stops just short of the top score.

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 triggering condition ('when the user wants to take one of their own listings off') and a hard precondition ('a listing that is part of a trade in progress can't be removed'). It stops short of naming an alternative tool (e.g. set_listing_status for temporarily deactivating instead of removing).

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=false, so the safety profile is covered. The description adds the useful behavioral consequence that saved listings appear via list_saved_listings, but omits whether re-saving duplicates or requires auth, so it is only modestly additive.

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 usage trigger and zero filler. Every sentence earns its place.

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

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

With an output schema present, return values need not be explained, and the description covers the use case plus the related listing tool. Minor gaps remain around idempotency and preconditions, but nothing essential to invoking 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?

There is a single parameter with 100% schema coverage (UUID format, regex pattern, and description 'The listing to save'). The description adds no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

The description clearly conveys the action (keeping/saving a listing) and its resource, and the title 'Save a listing' anchors the verb. It does not explicitly differentiate from siblings like create_listing or list_saved_listings, but the intent is unambiguous.

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

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

It gives a clear trigger condition ('when the user wants to keep a listing to come back to') and names the companion tool where saved listings surface (list_saved_listings), which helps route the agent. It stops short of naming when NOT to use it or contrasting against similar 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered structurally. The description adds real context beyond that: results are limited to ACTIVE listings (implying removed/expired ones are excluded), the fields each result carries, and the domain constraint that TraydStar is barter-only with no purchase semantics. It does not mention rate limits or auth requirements, but those are not implied by the annotations either.

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 the usage trigger, then the search facets and return shape, then a short domain caveat that prevents an agent from treating listings as purchasable. No filler or repetition of the 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?

For a 10-parameter, zero-required search tool with an output schema and full annotation coverage, the description covers purpose, trigger, scope (active only), and result contents. The 'TraydStar is barter only' caveat is valuable domain context, though slightly tangential to invocation. Return-value details are largely duplicated from the output schema, so 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 description coverage is 100% and each of the 10 parameters has its own description, so the schema carries the semantic load. The description only loosely gestures at the facets ('by text, category, or type') without adding format, default, or interaction details beyond the schema, 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 ('Searches active listings by text, category, or type') and scopes it to active listings, which cleanly separates it from get_listing (single fetch), list_my_listings, and list_saved_listings. The return-field list further pins down what an agent can expect, so the tool is identifiable without opening 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?

'Use this when the user wants to find goods or services offered for barter' gives a clear triggering condition for a search tool. It does not name the alternative retrieval tools (get_listing, list_my_listings, list_saved_listings) or state when not to use it, so it stops short of full routing guidance.

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

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

Annotations already mark this as destructive and non-read-only, but the description adds critical behavioral context: messages are delivered immediately, cannot be unsent, the recipient sees they were sent through an assistant, and there is a 3-message rate limit until a reply. This goes well 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?

Four sentences, each earning its place: usage, parameter routing, delivery/visibility/confirmation behavior, and rate limit. The most important usage guidance is front-loaded.

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

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

The description covers when to use, how to target recipients, irreversible delivery, assistant disclosure, confirmation requirement, and rate limiting. With an output schema present, return values need not be explained, so the definition is complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning by explaining the routing choice ('Give listing_id to reach that listing's owner, or to_user_id to reply to someone'), clarifying the purpose of to_user_id beyond its terse schema description.

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

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

States a specific verb and resource ('message another TraydStar member') and distinguishes the use case from formal proposals by noting 'before proposing a trade'. An agent can identify this as the direct messaging tool without opening 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?

Gives clear conditions for use ('when the user wants to message another TraydStar member') and explains how to choose between listing_id and to_user_id. However, it does not explicitly name alternative sibling tools or state when not to use this tool.

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

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

Annotations already flag destructiveHint=true and openWorldHint=true, and the description adds the concrete consequences the annotations cannot convey: pausing hides the listing from the marketplace and closes its pending proposals, plus a user-confirmation requirement. This is exactly the destructive-effect detail an agent needs before invoking.

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 with zero filler, front-loaded with the action set and followed by the destructive caveat. 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?

An output schema exists, so return values need not be described; the description covers the mode semantics, the destructive side effect, and the confirmation prerequisite. Nothing an agent needs to call this safely 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% and the status enum description already maps ACTIVE to publish/resume and PAUSED to hide, so the schema carries parameter semantics. The description's restatement of 'status is ACTIVE or PAUSED' adds no meaning beyond it; 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 specific verbs and resource: pause, resume, or publish a listing, and clarifies each mode's effect. An agent can distinguish this from siblings like update_listing or create_listing without opening 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?

Gives clear when-to-use guidance for each mode (pause/resume/publish) and an explicit prerequisite (confirm with the user first, since pausing closes proposals). It does not name a sibling alternative or state when not to use it, 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?

Goes well beyond the annotations (destructiveHint=true, openWorldHint=true) by spelling out that only provided fields change, that previous values are overwritten, and that the user should be asked to confirm first. It also discloses two hard preconditions (no edits during a trade, no photo changes), which the annotations cannot express.

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, front-loaded with the trigger, then the mutation semantics, then the two exclusions. No filler and nothing an agent must skip past to find the core instruction.

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, return values need no explanation, and the annotations already flag the destructive and open-world nature. The description covers the remaining gaps for a 10-parameter partial-update tool: partial semantics, confirmation requirement, and operational exclusions.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds a genuinely useful semantic: it is a partial update where only supplied fields are touched and existing values are overwritten, which is not captured in the schema. It does not describe units, formats, or enum meanings beyond what the schema already documents.

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 ('change one of their own active listings'), scoping it to the user's own listings, which cleanly separates it from create_listing, remove_listing, and set_listing_status. An agent can identify the operation without opening 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?

Gives a clear trigger ('when the user wants to change...') plus two explicit exclusions: listings in a trade in progress and photos. However, it never names the sibling tool or mechanism to use for the excluded cases, so the alternative path is only implied.

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 real behavioral context beyond the annotations: the tool does not move funds itself, it performs an external on-chain check, and it can return 422 while the transaction propagates. This softens the alarming destructiveHint=true by clarifying the side effect is a credit, not a fund transfer. It stops short of stating auth/permission requirements or idempotency on repeat calls.

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 the sequencing condition, then the side-effect disclaimer, then the failure handling. No sentence is filler and each carries distinct operational value.

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, return values need not be explained; what remains — when to call, what it does not do, and how to handle the transient 422 — is all supplied. Complete for a two-parameter verification tool.

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

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

Schema coverage is 100%, with both parameters fully described (tx_hash pattern, handshake_id uuid format) in the schema itself. The description adds no syntax or format detail beyond that, 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 ('verify the USDC Handshake fee', transfer 'checked on-chain and credited') and immediately distinguishes itself from get_handshake as the follow-up step. An agent can tell exactly what this does versus retrieving a handshake.

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 an explicit precondition ('after sending the USDC Handshake fee exactly as get_handshake instructed') and names the sibling that sets up the call. It also routes the 422 case ('wait a few seconds and call again'), covering the retry path rather than leaving the agent to guess.

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 openWorldHint=true, and the description adds concrete consequences beyond them: the handshake is cancelled, both listings remain listed, and the counterparty is notified. It also discloses the failure conditions (post-confirmation, fee paid) and the user-confirmation requirement, which is exactly the extra context annotations cannot carry.

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 short sentences, front-loaded with the trigger condition, then consequences, then blockers, then the safety step. 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?

With an output schema present, return values need no explanation. The description covers trigger, side effects, failure modes and required user confirmation, which is everything an agent needs to call this destructive mutation 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?

Only one parameter (handshake_id) and schema description coverage is 100%, so the schema already fully documents it. The description adds no format, sourcing, or lookup guidance for the ID, 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 ('call off a trade') plus the scope constraint ('that hasn't been confirmed by both sides yet'), which cleanly separates it from confirm_handshake, complete_handshake and withdraw_proposal in the sibling 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?

Gives explicit trigger conditions ('when the user wants to call off a trade') and explicit exclusions ('not possible once both sides have confirmed or if a fee has been paid'), plus a procedural requirement to confirm with the user first. Nothing about when to invoke is left to inference.

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

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

Annotations already declare destructiveHint=true, so the destructive nature is not new information. The description still adds value beyond them by stating the concrete consequence ('the proposal is closed and cannot be reopened') and imposing a confirmation workflow before invocation, which an agent cannot derive from the hints 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?

Three short sentences, front-loaded with the selection condition, followed by the consequence and the confirmation instruction. No filler and every sentence changes how an agent would act.

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 no explanation, and the description covers trigger, irreversibility, and the confirmation requirement. It leaves a minor gap around failure behavior (e.g., what happens if the proposal is no longer pending) but is otherwise sufficient for correct invocation.

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

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

With one parameter at 100% schema description coverage, the schema already documents proposal_id including its UUID format. The description only reinforces the 'pending' state constraint, adding marginal meaning beyond what the schema already conveys, so the baseline of 3 is appropriate.

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

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

The description names a specific verb and resource ('cancel a pending trade proposal they sent'), and the phrase 'they sent' scopes it to the sender's own proposal, which implicitly separates it from receiver-side siblings like decline_proposal or accept_proposal. It does not name any sibling explicitly, so full differentiation still requires reading the sibling 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?

It gives a clear trigger ('when the user wants to cancel a pending trade proposal they sent') and an explicit pre-action requirement ('Confirm with the user first'). It stops short of naming the alternatives (e.g., counter_proposal vs. withdraw_proposal) or stating when not to use it, so the routing guidance is clear but not exhaustive.

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