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

Annotations already signal mutation (readOnlyHint=false) and idempotency, but the description adds meaningful behavioral detail: it makes a network request, reserves the caller's one active legacy session slot, creates no blockchain transaction, and never signs or submits. This goes beyond what annotations alone provide and does not contradict them.

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 deliver the core purpose, usage constraints, workflow placement, alternative route, and side-effect profile with no filler. The most important fact—locking a fresh legacy quote into a v1 session—is front-loaded.

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

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

For a state-changing tool with five required parameters and no output schema, the description covers the prerequisite workflow, sibling distinction, network behavior, slot reservation, and explicit non-effects. An agent has enough context to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, and each parameter already has detailed meaning (e.g., fresh v1 quote UUID, wallet-bound token, caller-generated idempotency key). The description reinforces 'fresh legacy' and 'wallet-bound' concepts but adds little semantic value beyond the schema, 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 states a specific verb and resource: 'Lock one fresh legacy assetfare_quote into a wallet-bound v1 execution session.' It clearly distinguishes this from the v2 path by naming assetfare_v2_session_create as the alternative and by noting it is only for the legacy Solana-SOL-to-Base/Arbitrum-ETH workflow.

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?

Explicit guidance is given: 'Use only after legacy wallet authentication' and 'for a v2 quote use assetfare_v2_session_create instead.' This tells the agent both when to call the tool and which sibling to use when the precondition differs.

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, idempotentHint=false, and destructiveHint=false, so the description's statement 'Makes a network request and consumes login-challenge state, but never signs or submits' adds valuable context beyond the annotations—specifically clarifying non-idempotency and non-destructive behavior. It also flags the output as 'sensitive', which is not in the annotations. This is strong added value, though it doesn't detail error or token-expiry 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 two sentences with zero waste: the first sentence states purpose and output, the second provides usage constraints and side effects. It is front-loaded with the core action and uses phrasing that directly guides the agent without redundancy.

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

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

Despite having no output schema, the description mentions the returned output ('sensitive wallet-bound access token'), the network request, state consumption, and the exact conditions for use. For a four-parameter authentication tool with clear annotations and schema coverage, nothing essential an agent needs 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?

With 100% schema coverage, all four parameters (signature, challenge_id, source_wallet, terms_version) are already well-documented in the schema with type, constraints, and guidance. The description adds no additional parameter semantics beyond restating the legacy context; it does not compensate for any schema gaps because there are none. Baseline 3 is appropriate.

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

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

The description clearly states 'Verify the caller's signature over the exact legacy login challenge and return a sensitive wallet-bound access token,' which specifies a specific verb, resource, and outcome. It further differentiates itself from siblings by explicitly naming the prerequisite (assetfare_start_wallet_auth) and excluding v2 sessions, transaction signatures, and arbitrary messages.

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 commands 'Use only after assetfare_start_wallet_auth' and lists what not to use it for ('v2 session, transaction signature, or arbitrary message'), providing clear positive and negative use cases. This leaves no ambiguity for an agent choosing between this and the many sibling tools.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description reinforces this by stating it never creates state, signs, or submits, and adds that it reads an Ed25519-signed manifest and safety-bundle binding, plus the 'call once' guidance which implies idempotency. This adds value beyond the annotations without contradicting them.

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

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

The description is two sentences, front-loaded with the core purpose and followed by a concrete usage example. Every sentence contributes meaningful information without redundancy, and the structure is clean and scannable.

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

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

For a simple read-only tool with no parameters and an existing output schema, the description is complete. It explains what the tool reads, when to call it, and its safety guarantees. The presence of an output schema means the description need not detail return values, and the guidance covers the essential usage context.

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

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

The tool has zero parameters, so the input schema is trivially covered (100%). The description provides no parameter details because none exist, and per the baseline for 0-parameter tools, this is appropriate. No further explanation is needed.

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

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

The description clearly states the tool reads an Ed25519-signed release manifest and safety-bundle binding, which is a specific verb-resource pair. It distinguishes itself from siblings by emphasizing it's a verification step before preparation, and explicitly notes it never creates state, signs, or submits. However, it does not name any sibling tool to contrast with, so differentiation is implicit 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?

The description gives clear context: call this before preparing an action and once to verify current release and contract pins. It implies the tool is a prerequisite step and safe to use repeatedly, but it does not explicitly state when to avoid using it or mention alternative tools. The guidance is useful but not exhaustive.

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 that the tool makes a network request, never signs or submits, and advances the session record only after verification. This meaningfully clarifies the mutation semantics implied by readOnlyHint=false and idempotentHint=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?

Two dense sentences with no filler. The core action is front-loaded, followed by usage conditions and a safety-relevant behavioral note. 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 state-advancing tool with no output schema, the description covers prerequisites, alternatives, and side effects well. It does not describe return values or failure behavior, but the schema plus annotations cover invocation details sufficiently.

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

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

Schema coverage is 100%, so the schema already documents all four parameters in detail. The description adds contextual framing like 'caller-submitted' and 'legacy v1,' but does not add substantial parameter-level meaning beyond the schema.

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

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

The description opens with a specific verb and resource: verifying Circle attestation and forwarded USDC mints, then advancing the session record. It clearly distinguishes itself from siblings by explicitly contrasting with assetfare_read_session and the v2 observe 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 gives an explicit precondition: use only after the CCTP burn is submitted. It also names the correct alternative for inspection without advancement and for v2 routes, giving the agent concrete 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?

Beyond the annotations, the description adds meaningful behavioral context: it 'Makes a network request and advances session state, but never signs or submits.' This clarifies the side-effect profile even though readOnlyHint is false, and it does not contradict any annotation.

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

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

Three tight sentences, each earning its place: purpose, usage conditions and alternative, and behavioral boundary. The most important routing constraint is front-loaded.

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

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

For a four-required-parameter tool with no output schema, the description provides all essential selection and invocation context: workflow version, ordering requirement, side effects, and non-actions. There is no meaningful gap for an agent deciding to call it.

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%, with each of the four parameters already well documented in the schema. The description itself adds no extra parameter-level detail beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description immediately states a specific action — 'Verify an already-submitted destination UserOperation receipt' — and adds the legacy v1 workflow context. It distinguishes itself from sibling tools by naming the v2 alternative explicitly, so an agent can tell it apart without opening 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?

It gives an explicit precondition: 'Use only after the caller independently submits assetfare_prepare_destination_action'. It also names the alternative for v2 workflows, assetfare_v2_session_observe_output, making the routing decision 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?

Annotations indicate readOnlyHint=false, idempotentHint=true, and destructiveHint=false, and the description adds important context: it requires caller approval, advances preparation state, and never receives the event signer private key, signs, or submits. This meaningfully clarifies the safety and state-change profile beyond the annotation hints.

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

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

Three sentences with no filler: the action is front-loaded, usage routing is precise, and the security boundary is stated compactly. 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?

The description is complete enough for selecting and invoking the tool correctly, given strong schema coverage and annotations. It could be slightly stronger by indicating what the caller should expect as a result, especially since no output schema is present, but the core usage and safety context are well covered.

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 params are already well-documented. The tool description reinforces that the event signer is caller-owned, but this largely repeats the schema's existing 'caller-generated' and 'never send it' guidance, adding little new semantic value.

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

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

The description states a specific verb ('Prepare'), a clear resource ('unsigned CCTP burn'), and explicit scope ('current legacy v1 session'). It also distinguishes itself by noting what it never does—sign or submit—and implicitly differentiates from v2 sibling tools.

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

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

The description explicitly says to use it only when the legacy workflow reports it as the next action and names the v2 alternatives (assetfare_v2_prepare or assetfare_v2_session_create). This leaves no ambiguity about when this tool should be selected.

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

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

Annotations already indicate idempotentHint=true and readOnlyHint=false, but the description adds that it 'makes a network request and advances preparation state, but never signs or submits.' This goes beyond the annotations, clarifying side effects and what it does not do, which is valuable for an agent deciding to call it.

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

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

Two sentences, front-loaded with the core action and then the usage constraint. Every clause earns its place with no fluff. The key differentiator (v2 vs v1) is placed prominently in the second sentence.

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

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

Given the complexity of the tool and lack of output schema, the description covers the essential behavioral contract (network request, state advance, no signing) and the precondition. It does not describe return values, but the mutation nature makes that less critical. Minor gap: 'exact-cap permit' is domain jargon but likely understood in context.

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

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

Schema coverage is 100% with detailed descriptions for each parameter, including constraints like UUID format and min/max lengths. The description does not add any parameter-specific semantics beyond what the schema already provides, 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 clearly states the verb 'Prepare' and the specific resources: 'exact-cap permit and unsigned ERC-4337 destination settlement plan' for the 'legacy v1 session'. It distinguishes from v2 by explicitly referencing assetfare_v2_session_get, making it unambiguous which workflow it applies to.

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 states the condition 'when the legacy workflow reports the destination step and after caller approval' and contrasts with v2 sessions, telling the agent when not to use it and pointing to the alternative tool. This leaves no ambiguity about invocation context.

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

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

Annotations already indicate it is not read-only, not destructive, and idempotent. The description adds that it 'makes a network request and advances preparation state, but never signs or submits,' which clarifies the side-effect profile and the non-submission guarantee. This adds value beyond annotations, though it doesn't cover error behavior or return details.

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

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

Two sentences with no redundancy. The main purpose is front-loaded, followed by usage constraints and behavioral notes. 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?

The description covers prerequisites, alternatives, side effects, and what it does not do (sign/submit). The only gap is that it does not describe the return value or output format, which is notable since there is no output schema. Still, for a state-advancing step in a flow, the description is largely sufficient.

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

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

Schema coverage is 100% and both parameters have detailed descriptions in the schema itself. The tool description does not add parameter-specific meaning, but the schema already does the heavy lifting, so a 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 states a specific verb ('Prepare') and a specific resource ('bounded unsigned Solana source action'), and scopes it to the legacy v1 session step. It clearly distinguishes itself from v2 siblings by naming them, so an agent can tell it apart without opening other 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?

It explicitly states when to use it ('after assetfare_create_session and explicit caller approval') and when not to use it ('for a v2 route use assetfare_v2_prepare or assetfare_v2_session_create instead'). This is exactly the when/when-not/alternative guidance expected.

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, idempotentHint=true, and destructiveHint=false. The description adds specifics beyond annotations: it makes a network request and never authenticates, creates a session, prepares an action, signs, or submits. This aligns with annotations and provides richer behavioral context.

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

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

Two tightly packed sentences with zero filler. The core purpose is front-loaded, and the usage guidance and behavioral disclosure follow efficiently. 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 simple legacy quote tool with only 2 parameters, full schema coverage, and clear annotations, the description provides all necessary context: legacy status, exact corridor, and explicit routing to the v2 alternative. Nothing an agent needs 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 both parameters are fully documented in the schema. The description itself doesn't add parameter-level details beyond the route context, which is already clear from the purpose. Baseline 3 is appropriate since 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 ('get'), resource ('Solana SOL to Base or Arbitrum ETH pricing'), and clearly identifies it as the legacy v1 original-corridor quote. It explicitly differentiates from the v2 sibling tool, making the purpose unambiguous.

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

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

Explicitly instructs when to use ('with the unversioned legacy wallet-auth/session tools') and when not to ('for every new or six-chain evaluation use assetfare_v2_quote instead'). Names the alternative directly, leaving no ambiguity.

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, idempotentHint, and destructiveHint=false. The description adds useful behavioral context beyond those annotations: it 'makes a network request; never signs or submits' and states that the view selection 'never advances the workflow.' No contradiction with the annotations exists.

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

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

The description is two sentences with no filler. It front-loads the primary action, then adds the key routing instruction and safety caveat. 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 simple read-only tool with 3 fully described parameters and no side effects, the description is nearly complete. It covers purpose, usage, legacy vs v2 routing, and behavioral guarantees. It could go slightly further by describing the shape of the returned data, but the absence of an output schema is mitigated by the description stating exactly which projections can be read.

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 does not add much parameter-level meaning; the schema already documents view projections, the legacy session UUID, and the sensitive access token. The phrase 'current unsigned action' slightly reinforces the next_action enum, but the schema already explains this.

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

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

The description opens with a specific verb and resource: 'Read a legacy v1 session summary, workflow state, receipt, or current unsigned action.' It clearly identifies the legacy v1 scope and distinguishes it from v2 tools by naming the exact alternative (assetfare_v2_session_get).

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 when to use the tool ('inspect or resume a session created by assetfare_create_session'), when not to use it ('for a v2 session use assetfare_v2_session_get instead'), and what to avoid ('do not use this call to advance state'). This fully routes an agent to the correct 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 only declare readOnlyHint=false, which could imply a mutating operation, but the description clarifies the actual scope: 'Makes a network request and creates login-challenge state, but cannot move funds, sign, or submit.' This meaningfully contextualizes the non-read-only hint and prevents the agent from assuming the tool can execute transactions. No contradiction with annotations.

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

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

Three sentences with zero waste: the first fronts the core purpose with key qualifiers, the second provides usage conditions and exclusion, the third discloses behavioral limits. Every sentence earns its place and the most decision-relevant information appears first.

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

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

For a single-parameter tool with no output schema, the description covers purpose, preconditions, exclusions, and behavioral safety limits comprehensively. The only minor gap is that it doesn't name the natural follow-up step (e.g., assetfare_finish_wallet_auth) or hint at the response shape, but the sibling naming and 'login-challenge state' mention make this a small omission rather than a blocking one.

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

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

Schema description coverage is 100% — the sole parameter 'source_wallet' is already well documented in the schema as a caller-owned public address with an explicit warning against seed phrases/private keys. The tool description adds only indirect context (the fresh quote precondition), so the schema carries the heavy lifting and 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 states a specific verb ('Create') and a specific resource ('short-lived, non-transactional Solana signMessage challenge'), scoped precisely to the legacy v1 workflow. It also distinguishes itself from the sibling family by explicitly noting that v2 quote and session tools do not use wallet authentication, so an agent can route correctly without opening 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?

The description gives explicit preconditions ('Use only after selecting a fresh legacy assetfare_quote and obtaining caller approval') and an explicit exclusion ('v2 quote and session tools do not use wallet authentication'). This tells the agent both when to invoke this tool and when not to, leaving little 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 readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the bar is lower. The description adds value beyond them by disclosing 'makes a network request' (latency/connectivity implications) and 'never authenticates, signs, submits, or advances a session' — exclusions that matter given session- and auth-oriented siblings. The leading 'Read-only' slightly echoes readOnlyHint, but the rest is genuinely 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?

Three sentences with zero waste: purpose, usage routing, and behavioral caveats. The main purpose is front-loaded, and each sentence earns its place. The only redundancy is the word 'Read-only' echoing readOnlyHint, which is negligible given the new information packed into the same sentence.

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 0-parameter read-only status tool with rich annotations, this is nearly complete: purpose, workflow placement, and behavioral exclusions are all covered. The return format is not specified (no output schema exists), but the output is strongly implied by the stated purpose — compatibility status and safety gates — so this is a minor gap rather than a serious one.

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?

Tool has 0 parameters with an empty schema (additionalProperties: false), so the baseline is 4 and there is nothing for the description to document. No parameter semantics are needed or expected here.

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

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

Description opens with a specific verb+resource: 'Read legacy v1 compatibility status and original-corridor safety gates.' It explicitly names what it is not by routing v2 workflows to assetfare_v2_capabilities, which distinguishes it from the closest sibling 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 positive condition ('Use only before the unversioned Solana-SOL-to-Base/Arbitrum-ETH workflow') and an explicit exclusion with the named alternative ('for every six-chain v2 route use assetfare_v2_capabilities instead'). This is textbook when/when-not guidance with a specific sibling fallback.

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?

While annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, the description adds valuable transparency by stating it 'creates no wallet login, session, or action'. This explicitly rules out side effects beyond what annotations imply, which is critical for a pre-quote check tool. No contradiction with annotations.

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

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

Two concise sentences: the first states the primary purpose and the second provides a concrete example and explicitly mentions read-only behavior. The critical information is front-loaded, and every sentence earns its place. No wasted words.

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

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

For a zero-parameter read-only tool with an output schema, the description is complete. It states what is read, gives an example of how to interpret the output, and clarifies side effects. The agent has enough to correctly invoke and interpret the tool without additional context.

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

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

The tool takes zero parameters, so the baseline is 4. The description does not need to explain parameter semantics, and it doesn't; it focuses on the tool's purpose and example usage. This is appropriate given the empty schema.

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

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

The description clearly states a specific verb ('Read') and resource ('76-route capability and live-availability matrix'), and explicitly positions it as a pre-quote step. The example (solana:USDC->base:USDC) further clarifies the specific capability checks, distinguishing it from sibling tools like quote, prepare, and session operations.

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

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

The description explicitly says 'before quoting', giving clear temporal guidance. It does not explicitly name alternatives or when-not-to-use, but the purpose is so specific that an agent would naturally select this tool for capability checks prior to quote operations. The example also reinforces the intended use case.

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 read-only and non-destructive, so the safety profile is covered. The description adds useful behavioral context beyond annotations: no network call is made, the output is a sensitive bearer capability, and it is never a private key. This is meaningful additional transparency without contradicting the annotations.

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

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

The description is compact and front-loaded with the most important constraint ('Local stdio only'). Each sentence adds distinct value: scope, generation mechanics, and security classification. There is no fluff or redundant restatement of the tool name.

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 zero parameters and an output schema present, the description covers everything an agent needs to know: when to use it, how remote clients should behave instead, where the result should be passed, and the security sensitivity of the value. 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?

The tool has zero parameters and the schema is empty, so the baseline is 4. The description compensates by clarifying the semantic nature of the generated value and how it is encoded, which is the only parameter-like information an agent needs.

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 ('generate') and a specific resource ('one caller-owned 256-bit session capability') without a network call. It also clearly distinguishes the local stdio context from remote MCP/A2A servers, so an agent can differentiate this from the many session-related siblings.

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

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

The description explicitly says this helper is local stdio only and that remote clients should generate the capability themselves by producing 32 random bytes and base64url-encoding them. It also instructs that the result should be passed to assetfare_v2_session_create and every lifecycle call, giving concrete usage direction.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, openWorldHint=true — indicating mutation risk. The description accurately signals this by mentioning 'state-changing preparation or session creation' in the caller_approved parameter, and clarifies that AssetFare never signs or submits. It also discloses the hash-scope behavior (payload_sha256 omits only itself, MCP adapter does not append fields). The main gap is that it doesn't explicitly warn that this is a state-changing operation in the description body itself, though the annotations and parameter descriptions cover this. The description adds meaningful behavioral detail beyond annotations about the unsigned nature and the no-sign/no-submit guarantee.

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 reasonably compact for a complex tool with 8 parameters and nested wallet objects. Every sentence earns its place: the first sentence states the core function, the second clarifies the hash scope, the third gives a usage example, and the fourth provides routing guidance. It could be slightly more concise in the example sentence, but the density is high and front-loaded.

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

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

Given the tool's complexity (8 params, nested wallets, conditional event_signer_public, chain-token constraints, state-changing nature), the description plus schema covers nearly all needs. The output schema exists, so return values don't need explanation. The description covers the key safety aspects (never send private keys, never both modes, no sign/submit), the economic/representative amounts, and the conditional Solana signer. Minor gap: the 'exact route' phrase in the description is slightly ambiguous, but the schema's chain/token enums and descriptions resolve it.

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

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

Schema coverage is 100%, so the schema already documents every parameter. However, the description adds substantial semantic value beyond the schema: it explains the relationship between amount_usd values ('USD 1 is smoke only', 'USD 50 is the native-USDC economic-comparison start based on dated evidence', 'USD 1,000 is the primary representative amount'), explains when event_signer_public is required ('when required' in description, 'Solana CCTP only' in schema), and clarifies that caller_approved must be a fresh re-quote approval. The description and schema complement each other exceptionally well.

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 ('Return'), a precise resource ('the exact validated versioned Core bundle'), and the condition under which it applies ('for the first caller-approved unsigned action after a fresh re-quote'). It clearly distinguishes this one-shot preview mode from session mode, and explicitly names the sibling it is not ('Use instead of session mode'). It also adds precise technical detail (payload_sha256 covering the Core bundle with only payload_sha256 omitted) that differentiates it from all sibling tools.

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

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

The description explicitly states when to use this tool ('one-shot preview'), when not to use it ('never call both modes'), and names the alternative (session mode). It also gives concrete prerequisites: pass caller_approved=true, the exact route, public wallets, and a caller-owned Solana event signer when required. This is explicit and actionable 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 provide readOnlyHint=true and destructiveHint=false, but the description adds rich behavioral detail beyond them: the quote is 'fresh' and 'fee-inclusive,' SOL input includes a swap, and the cost comparison is not a guarantee ('not a guarantee AssetFare is cheapest'). The explicit 'Read-only; never authenticates, prepares, signs, or submits' reinforces the safety profile without contradicting the annotations.

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

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

The description is dense but purposeful. It front-loads the action and example, then adds caveats and a read-only note. Every sentence earns its place, though the phrase 'caller-operated unsigned-plan handoff' and the dated '2026-09-23 evidence' could be simplified for readability. It is not overly verbose, but slightly more structure would improve scannability.

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

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

Given the output schema exists (so return values are covered) and annotations already provide the read-only/destructive profile, the description covers the essential usage details: a representative example, amount-behavior thresholds, SOL swap note, and an explicit no-auth/prepare/sign/submit guardrail. The 'unsigned-plan handoff' phrase is a bit cryptic, but the output schema likely clarifies the handoff structure. Overall, an agent has enough to correctly invoke this tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds significant meaning beyond the schema: it provides a full example mapping all five parameters, explains the distinct semantics of amount_usd values (1 = smoke, 50 = comparison start, 1000 = representative), and warns that SOL input includes a swap. This is genuinely helpful additional context that the schema's enum and minimum descriptions do not convey.

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

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

The description opens with a specific verb and resource: 'Get one fresh fee-inclusive quote and caller-operated unsigned-plan handoff.' This clearly distinguishes it from sibling tools like prepare and session tools, and the worked example ('from_chain='solana', from_token='USDC'...') concretely pins down the tool's job. No confusion about what this tool does.

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

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

The description gives explicit context about when to use the tool: amount thresholds (USD 1 smoke, USD 50 economic-comparison start, USD 1,000 representative) and a directive to 'Always compare fresh candidates at the actual intended amount.' It also states 'never authenticates, prepares, signs, or submits,' which implicitly tells the agent not to use this tool for those actions. It does not name sibling tools directly, but the exclusions are clear enough.

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, idempotentHint=true, and destructiveHint=false. The description adds meaningful behavior: it creates a state-changing session, returns an unsigned action, and explicitly states 'AssetFare never signs or submits.' It also clarifies the idempotency key and approval semantics. This goes beyond what annotations convey, exposing core operational boundaries without contradicting them.

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 plus an example. The example is compact and informative, and the negative guidance ('never alongside one-shot prepare', 'never signs or submits') is efficient. It is slightly dense with terms like 'receipt-driven' that are not defined, but overall it earns its place and front-loads the core purpose.

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

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

The tool has 10 params, nested wallets object, output schema, and rich annotations. The description covers the workflow type, approval gating, idempotency, and the no-signing/no-submission boundary. It does not explain what 'receipt-driven' means or fully map the returned unsigned action's role, but the output schema and sibling tools (session_get, refresh_action) provide surrounding context. Adequate for a complex creation tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds a useful example (session_token, wallets, idempotency_key) and calls out the semantic distinction that amount_usd is a requested input, not a guaranteed quote. It does not deepen understanding of each parameter since the schema already documents them thoroughly. Meets the baseline without exceptional added value.

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

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

The description states a specific action: 'Create one caller-approved receipt-driven workflow and return its current unsigned action.' It names resources (session, unsigned action, AssetFare) and gives an example. It does not explicitly distinguish from siblings by name, but the one-shot vs multi-step contrast and 'never signs or submits' help position it. Slight ambiguity remains around what 'receipt-driven' means for an agent encountering the tool cold.

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

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

The description gives an example invocation pattern and explicitly says to use it for multi-step execution and 'never alongside one-shot prepare.' It names the alternative style ('one-shot prepare') but does not name the sibling tool assetfare_v2_prepare directly; the context signals show that sibling exists. It does not mention when to use session_get or refresh_action instead, but the primary routing decision is 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 readOnlyHint, idempotentHint, and destructiveHint=false, so the description does not need to restate those. It adds meaningful behavioral nuance: the read does not advance the workflow, it never signs or submits, and the session_token is caller-owned and sensitive. This goes beyond the annotation baseline.

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 deliver the core purpose, key behavioral constraint, and a realistic example. It is front-loaded and contains no filler or repetition of schema details.

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

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

This is a simple two-parameter read tool with rich schema descriptions, comprehensive annotations, and an output schema present. The description covers purpose, usage timing, and behavioral guarantees, leaving no significant gap 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?

Schema description coverage is 100%, and both parameters already have strong descriptions covering format, origin, sensitivity, and usage constraints. The description only mentions passing session_id and session_token in the example, which adds no new semantic detail beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Read an existing v2 workflow and current unsigned action.' It also states the key scope constraint, 'without advancing it,' which distinguishes it from advancing or refreshing actions. This clearly separates it from session creation, preparation, quoting, and observation siblings.

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

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

The description gives a concrete usage scenario ('after a restart') and explicitly warns that the tool is read-only and never signs or submits. However, it does not name sibling tools or provide exclusion criteria for when to use an alternative like session_refresh_action or session_observe_output. Usage context is implied rather than fully specified.

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 adds the important guarantee that AssetFare 'never signs or submits' and that the tool records an external output and advances workflow state. This is contextually valuable and does not contradict the readOnlyHint=false or idempotentHint=true annotations.

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

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

The description is two sentences plus one concrete example. It front-loads the core action and adds the safety-relevant detail about not signing or submitting without any 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?

Given the rich parameter schema, output schema, and clear annotations, the description is sufficient for an agent to understand what the tool does and when to use it. It does not spell out the full workflow sequencing around source observation, but sibling names and parameter documentation cover that context.

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

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

Schema description coverage is 100%, and the schema already fully explains session_token, session_id, idempotency_key, and transaction_hash. The description adds a useful example pairing transaction_hash with idempotency_key, but no substantial new parameter meaning 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?

The description uses a specific verb ('Record') plus a specific resource ('already-produced bridge or destination output') and states the workflow effect ('advance the workflow'). This clearly distinguishes it from the sibling observe_source tool by targeting the output side of the workflow.

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

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

It clearly scopes usage to already-produced outputs and emphasizes that AssetFare only observes and never signs or submits, which shapes when an agent should call it. It does not explicitly name an alternative tool or state exclusions, but the context is strong enough 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 indicate mutation and idempotency, but the description adds context: it records hashes and advances the workflow, and explicitly states it never signs or submits. This goes beyond the annotations without contradicting them.

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

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

The description is two sentences, front-loaded with the core action and followed by a concise caution. The example is directly useful and the structure is efficient with no wasted words.

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

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

Given the output schema exists, return values need not be described. The description covers the essential purpose, constraints, and an example. It could mention when to use this vs. the output observation tool, but that's not critical for correct usage.

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 each parameter is documented in the schema. The description adds an example and a constraint on transaction_hashes, providing modest extra value beyond the schema's parameter descriptions.

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

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

The description states a specific verb ('Record') and resource ('source hashes'), and clarifies it advances the workflow. It distinguishes from sibling tools by specifying 'source' rather than 'output' hashes, making the purpose unambiguous.

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

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

It provides clear constraints: 'Never pass an unsigned hash' and clarifies that AssetFare never signs or submits. The example with idempotency_key offers concrete usage. It doesn't explicitly name alternatives like assetfare_v2_session_observe_output, but the source/output distinction is 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?

Beyond the annotations, it warns that AssetFare never signs or submits and that refresh is valid only while the action remains unsubmitted. It doesn't detail the exact effect of refresh or failure mode on misuse, but the safety-critical behavior is disclosed.

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-load the purpose, include a compact example, and finish with a necessary safety constraint. 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?

The rich schema, output schema, and annotations carry most structural context, and the description adds the crucial unsubmitted-only and never-signs/submits constraints. It could define what 'expired' means or mention expected failure behavior, but nothing essential is missing 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?

The input schema already documents all three parameters in detail (100% coverage), so the description adds little parameter-level meaning. The example shows existing session_id/token and a refresh-specific idempotency key, but that mainly reinforces schema guidance.

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

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

The description opens with a specific verb and resource: refresh an expired action, and immediately narrows scope to unsubmitted actions. This clearly separates the tool from create/get/observe siblings and from any submit-related step.

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 an explicit when (expired, unsubmitted action) and when-not (never on a submitted step). It does not name an alternative tool for submitted actions, so it falls just short of full routing guidance.

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

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

The description discloses that the tool advances the legacy workflow, makes a network request, requires caller approval, and never signs or submits. These nuances go beyond the annotations (which only mark readOnly, idempotent, destructive hints) and give the agent a clear picture of side effects and limits.

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

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

Two compact sentences front-load the purpose, sequence prerequisite, v2 alternative, and key behavioral constraints. Every sentence earns its place with no redundant information.

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

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

The description is complete for tool selection and sequencing, covering prerequisites, alternatives, and safety behaviors. However, it does not describe the expected output or failure modes, which would help an agent handle the response properly; this is a minor gap given the absence of an 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 input schema already provides 100% coverage with detailed descriptions for all four parameters. The main description does not add any parameter-specific meaning beyond what the schema documents, 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 states a specific verb ('verify') and resource ('finalized Solana source signature') and explicitly places it in the legacy v1 workflow. It also names the v2 alternative, clearly distinguishing it from sibling tools like assetfare_v2_session_observe_source.

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

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

The description gives an explicit precondition ('Use only after the caller independently submits assetfare_prepare_source_action') and an explicit alternative for v2 sessions. It also notes caller approval and network usage, leaving no ambiguity about when to use this tool versus its siblings.

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