schwab-mcp

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

With no annotations, description discloses that the tool is free (no credits consumed) and requires authentication via dpop_token. It also clarifies the scope (patron's spending account) and the data returned. No contradictions or missing key behaviors.

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

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

Four sentences, each adding distinct value: action, contents, differentiation, and cost/requirement. Front-loaded with core purpose. No redundant or ambiguous phrasing.

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

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

Description covers what the tool returns, cost, and authentication requirement. Has output schema to handle return structure. However, could explicitly differentiate from sibling schwab_account_statement_infographic for completeness.

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 covers 100% of parameters with clear descriptions (e.g., days, npub, dpop_token). The description adds no additional meaning beyond what's in the schema, so baseline 3 is appropriate.

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

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

Description clearly states it generates a patron's account statement, lists specific contents (purchase history, credit tranches, usage breakdown, logs), and distinguishes from the operator's Authority tax balance. The verb 'Generate' is specific and the resource is well-defined.

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?

Description provides clear context: free, requires proof of npub ownership, and is for patron's spending account. It implicitly suggests when to use (patron-specific info) but does not explicitly exclude alternatives like schwab_account_statement_infographic.

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

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

With no annotations, description fully covers behavioral traits: costs 1 api_sat, proof verified by debit_or_deny, and details of SVG content (dark-themed with specific elements).

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 with clear front-loaded purpose, no redundant information, efficient structure.

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 output schema exists, description adequately covers cost, verification, and visual elements. Lacks detail on return format but compensated by 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 covers 100% of parameters with descriptions, so baseline is 3. Description does not add additional semantics beyond 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?

Clearly states it generates a visual SVG infographic of an account statement, distinguishing from sibling 'schwab_account_statement' by specifying it renders the same data as a dark-themed graphic with specific components.

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?

Implies usage when a visual representation is needed versus raw data from account_statement, and provides cost and verification context. Does not explicitly state when not to use.

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

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

With no annotations, the description carries the burden. It indicates a read-only polling operation ('Check', 'Polls') and states it is free. However, it lacks details on authentication requirements (dpop_token role), failure modes, or whether it modifies state. Provides moderate transparency.

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 front-loaded purpose and no fluff. Every sentence adds value: first states the core action, second explains it is free and polls. Extremely concise.

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 status-check tool, the description covers the main use case. It lists possible statuses and mentions polling. However, it omits prerequisites (e.g., a prior adoption request), output details (though output schema exists but not described), and potential errors. Adequate but could be more 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 0%, so description must compensate. The description only loosely explains 'authority_npub' as 'chosen Authority' and fails to describe 'dpop_token'. No parameter details beyond the name, leaving agents to infer format or 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 clearly states the action ('Check') and the resource ('adoption-request status at a chosen Authority'). It distinguishes from sibling such as 'schwab_request_adoption' which creates a request, and the specificity of 'this operator' and 'adoption-request' differentiates it from similar status-check 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 implies usage when needing to check adoption status and mentions it is free and polls an authority. However, it does not explicitly state when not to use it or provide alternatives (e.g., 'schwab_request_adoption' for creating a request). Usage is implied but not fully guided.

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?

Discloses that the tool is free, requires proof of npub ownership to prevent DOS, and returns an authorization URL. Could be more explicit about side effects if called multiple times, but overall transparent.

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?

Well-structured with clear sections, but slightly verbose. Front-loads the purpose and includes necessary instructions.

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 presence of an output schema, the description sufficiently covers the flow, prerequisites, and error handling. No gaps in essential information.

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?

Adds context beyond the input schema by explaining that dpop_token is a kind-27235 Nostr event signed by npub, and that proof of ownership prevents DOS. The schema already has 100% coverage.

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

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

The description clearly states it starts the OAuth2 authorization flow and returns an authorization URL. It specifies the action (begin OAuth) and distinguishes it from sibling tools like check_oauth_status.

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 not to call pre-emptively and only when a live tool call fails with 'upstream_auth_refresh_needed'. Also directs to call check_oauth_status with the same npub to complete the flow.

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

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

No annotations provided, so description carries full burden. It discloses the tool returns sats for certifying purchases, behavior when balance is zero, and that it's operator-specific. Implies read-only operation ('check'). No contradictions.

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

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

Five sentences, each adds value. First sentence states purpose clearly. No filler. Efficient and well-structured.

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

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

For a zero-parameter tool with no annotations and an output schema, the description covers purpose, return value meaning, behavioral consequences, and ownership distinction. Complete and self-contained.

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?

No parameters exist, so schema coverage is 100%. Baseline 4 as per rules for zero-parameter tools. Description adds no parameter info but doesn't need to.

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

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

Description clearly states the tool checks the operator's tax balance at the Authority, specifying it's for certifying patron credit purchases. Distinguishes from sibling tools like schwab_check_balance by noting this is the operator's own funding, not a patron balance.

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

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

Provides context for when to use: to check available sats for patron top-up certification. Explicitly states what happens when balance is zero and that the operator should call purchase_credits. Implicitly advises against using for patron balance checks. No direct alternative naming but clear usage scenario.

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

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

No annotations are provided, but the description fully explains behavioral traits: the tool is free (no credits), requires a dpop_token for proof of ownership, and is a read operation on the patron's balance. No contradictions or omissions.

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 concise with three sentences, front-loaded with the primary purpose, and includes essential context (free, authentication, sibling distinction) without unnecessary 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 low complexity, 100% schema coverage, and presence of an output schema, the description covers all needed context: what the balance represents, authentication requirement, and alternative tool. It is complete for an agent to select and invoke correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add new semantic details beyond what the input schema already provides for both parameters (npub and dpop_token).

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 checks a patron's credit balance at this operator, specifying it is the spending balance for tool calls. It distinguishes from the sibling 'authority_check_balance' for the operator's own balance, ensuring no ambiguity.

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

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

Explicitly tells when to use this tool (patron's balance) and when to use the alternative ('authority_check_balance'). Also notes it is free and requires proof of npub ownership, providing clear context for usage.

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?

Discloses authorization requirement (npub ownership) and the nature of the OAuth status check, including limitations. Compensates for lack of 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?

Concise at 87 words, no fluff. Key information is front-loaded and structured logically.

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 existence, description sufficiently covers usage context, semantics, and limitations. Complete for its purpose.

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 covers 100% of parameters with descriptions; description adds minimal extra value (only notes consistency with begin_oauth). Baseline 3 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?

Clearly states the tool checks OAuth2 completion and distinguishes it from related tools like begin_oauth.

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 describes when to use (after begin_oauth and login completion) and when not to misinterpret results (pending does not prove session lapsed). Provides fallback 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?

Without annotations, the description discloses key behavioral traits: it is free ('no credits required') and requires authentication via dpop_token. It does not explicitly state side effects or return behavior, but for a status check tool, the provided information is sufficient. Some additional details about idempotency could improve transparency.

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

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

The description is three sentences, each serving a distinct purpose: stating the action, providing usage context, and mentioning key features (free, authentication). It is concise, front-loaded, and contains no unnecessary information.

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

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

For a simple status-check tool with an output schema, the description covers the essential context: what it does, when to call it, prerequisites, and cost. The presence of an output schema means return values do not need to be described. No gaps are apparent.

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 descriptions already cover all three parameters with clear explanations. The description adds value by explaining why npub is needed (proof of ownership to prevent front-running), but does not introduce new syntax or format details. Given 100% schema coverage, this is a solid enhancement.

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's purpose: 'Check the payment status of a Lightning invoice.' It specifies the verb (check), the resource (payment status), and provides context about when to use it (after paying from purchase_credits), distinguishing it from related 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 the tool: 'Call after paying the invoice from purchase_credits.' It also explains the prerequisite (proof of npub ownership) and the reason for it (to prevent front-running), providing clear guidance on usage 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?

Without annotations, the description fully discloses that the tool is a read-only preview ('Preview,' 'Shows') and that it is free. It clarifies what information is shown (base cost and constraint effects), but does not detail error behavior or authentication 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?

The description is extremely concise: two sentences with no wasted words. The purpose is front-loaded, immediately stating the tool's function.

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

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

The description covers the core function and cost implications, but with four parameters and no annotation details, it lacks full context for proper invocation. The presence of an output schema mitigates the need to describe return values, but parameter semantics remain under-explained.

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

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

Schema description coverage is 50%, but the description adds no parameter-level meaning. It does not explain the purpose of 'npub' or 'dpop_token,' nor does it elaborate on the usage of 'tool_id' and 'tool_kwargs' 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 clearly states the tool's purpose: 'Preview the effective cost of a tool call.' It specifies the verb ('Preview') and resource ('effective cost'), and distinguishes it from sibling tools like 'schwab_check_balance' or 'schwab_check_payment' by focusing on cost preview.

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 mentions 'Free — no credits required,' providing a usage condition. However, it does not explicitly state when to use this tool versus alternatives like other 'check' tools, nor does it offer exclusions or alternative tool suggestions.

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

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

With no annotations provided, the description fully handles behavioral disclosure by stating it is free, has no side effects, and does not evict the cache or touch relays. This is explicit and complete.

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 very concise with only three sentences, front-loading the main purpose. Every sentence adds value, 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?

Given the tool is a simple check with an output schema, the description covers purpose, usage context, and behavioral traits. It is complete for effective agent 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%, so the baseline is 3. The description does not add extra parameter details beyond the schema, which is acceptable given the schema already describes both parameters clearly.

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 checks whether a cached dpop_token is still valid, with a specific verb and resource. It explicitly distinguishes itself from the sibling tool 'schwab_check_oauth_status' by naming it and describing the mirroring relationship.

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 advises using the tool before a paid call to avoid wasted credits, providing practical guidance. It lacks explicit 'when not to use' statements, but the context is sufficiently 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?

Since no annotations are provided, the description bears full responsibility for behavioral disclosure. It explains that deletion cascades to all patron redemptions and that chain steps referencing the coupon become no-ops, which is valuable context. It does not mention whether the operation is reversible or any other side effects, but the essential behavioral traits are covered.

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 extremely concise: three short sentences that front-load the primary action, then detail cascading effects, and finally state access restrictions. Every sentence adds necessary information with no redundancy or filler.

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

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

Given that an output schema exists (indicated by context signals), the description does not need to detail return values. It adequately covers the operation's purpose, consequences, and authorization requirements. It could be improved by mentioning prerequisites like coupon existence or error conditions, but overall it provides sufficient context for a delete operation.

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 has two parameters (coupon_id and dpop_token) but the description mentions neither explicitly. With 0% schema coverage, the description should compensate by describing parameter purposes and formats. It only implies coupon_id through context, and dpop_token is completely ignored, leaving the agent uncertain about its usage.

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 starts with 'Delete a coupon,' which directly states the action and resource. It clearly distinguishes this tool from siblings like schwab_mint_coupon, schwab_update_coupon, and schwab_list_coupons by focusing on deletion.

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 that the tool is restricted to operators and requires proof, which sets clear usage boundaries. It also explains cascading effects on redemptions, helping the agent decide when this tool is appropriate. However, it does not explicitly mention alternatives or when not to use it.

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

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

No annotations provided, so the description must cover behavioral traits. It states it's a write to a sensitive vault and requires proof of ownership, which is good. However, it doesn't mention what happens if the field doesn't exist, whether the operation is reversible, or success/error responses.

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 concise with three sentences, each adding value: purpose, nuance, and requirement. No unnecessary 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 presence of an output schema and no annotations, the description covers the basic context but lacks details on idempotency, existence requirements, or error cases. It is adequate but not fully complete.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description does not add additional meaning beyond what the schema provides, so 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 action ('Remove a single patron credential field') and the resource ('credential field'). It provides additional context (deletes without affecting other fields, free, requires proof of ownership). This distinguishes it from siblings like 'forget_credentials' which may delete all.

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

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

The description implies usage for deleting a single field but does not explicitly mention when to use or not use this tool compared to alternatives. It mentions the requirement of npub ownership but lacks guidance on when to prefer this over update or forget 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?

With no annotations, the description fully discloses behavioral traits: cosmetic effect, coupon still exists, re-redeemable, cost free, prerequisite npub. No contradictions.

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 purpose, every sentence adds value. No extraneous text.

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

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

Covers purpose, behavior, and prerequisites adequately. Output schema exists so return values need not be explained. Minor gap: no link to coupon_id meaning.

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

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

Schema coverage is 0% and description only mentions npub as proof, leaving coupon_id and dpop_token unexplained. Does not add sufficient meaning beyond 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 the action ('Remove a coupon from this patron's redemption list') and distinguishes from sibling tools like delete_coupon by emphasizing it is cosmetic only.

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

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

Provides context (cosmetic, not deletion, free, requires npub) but does not explicitly state when to use vs alternatives like delete_coupon or redeem_coupon.

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

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

With no annotations, the description reveals that deletion is 'as destructive as a write' and requires proof of npub ownership. It lacks details about success/failure responses, but the presence of an output schema mitigates the need to explain return values.

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

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

The description is three sentences, front-loads the action, and every sentence serves a purpose: stating the operation, providing usage scenarios, and warning about destructiveness. 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?

The description covers the core purpose, usage context, and behavioral trait. It doesn't explain what 'vaulted credentials' are or error conditions, but given the output schema and context signals, it is sufficiently complete for an AI agent.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining how to use the 'npub' parameter (operator vs patron) and the purpose of 'dpop_token' as proof. This goes 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 clearly states 'Delete vaulted credentials for a specific service and npub,' using a specific verb and resource. It distinguishes the tool from siblings (e.g., schwab_delete_coupon) by explicitly mentioning credentials and npub ownership.

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

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

The description provides explicit guidance on when to use the tool: for operator vs patron credentials, specifying which npub to pass. It also notes the prerequisite of proof of ownership via dpop_token, and emphasizes the destructive nature.

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

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

With no annotations, the description fully discloses critical behaviors: it is free, proof-gated, and explains the security rationale (IDOR prevention). No contradictions with annotations (none exist).

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

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

Well-structured: first sentence gives purpose, followed by usage flow and security context. Every sentence adds value, 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?

Given the complexity (OAuth dependency, proof-gating, next steps), the description is complete. It includes security context, cost, and expected output (account hashes). Output schema exists but is not needed for completeness here.

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 baseline is 3. The description does not add significant extra meaning for the parameters beyond what the schema already provides for 'npub' and 'dpop_token'.

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 starts with a clear verb ('List') and specific resource ('Schwab account numbers and their hash identifiers'), immediately distinguishing this tool from siblings that deal with orders, balances, statements, etc.

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

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

Explicitly states when to use ('after completing OAuth'), prerequisites (proof-gating via request/receive_npub_proof), and what to do next (call update_patron_credential). Also warns against misuse (IDOR attack) and notes it is free.

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 thoroughly explains the Day P&L computation, including two fallback guards (missing snapshot and suspect snapshot). It details edge cases and their outputs, providing high transparency without 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 well-structured with clear sections and bullet points, but it is verbose for a balance summary tool. Not every sentence is strictly necessary, though it provides valuable edge-case explanations.

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 an output schema, the description fully explains return values, computation logic, and fallback behavior. It also suggests cross-referencing with get_brokerage_positions, covering practical use.

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

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

The input schema has two parameters (npub, dpop_token) with 50% description coverage. The tool description adds no additional meaning beyond the schema, leaving dpop_token unexplained.

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

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

The description clearly states the tool retrieves the active Schwab account's current balance summary, listing four specific values: Cash Balance, Buying Power, Net Liquidation, and Day P&L. It is highly specific and distinct from sibling tools like position or order retrieval.

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 explicit guidance on when to use this tool versus alternatives like get_brokerage_positions or other balance-related tools. The description focuses on output details but omits context about appropriate scenarios for 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?

Despite no annotations, the description discloses the return format (markdown row) and that the average fill price is computed across executionLegs. Lacks auth or rate limit info, but acceptable for a read operation.

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

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

Concise, well-structured with a bullet point showing output format; no unnecessary 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 simple operation and presence of output schema, the description fully covers what the agent needs to know.

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 67% with both documented parameters having clear descriptions; the description reinforces the order_id context.

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

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

Clearly states it gets full details for a single order by Schwab order ID, and references the sibling get_brokerage_orders for format consistency.

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: when you already have an orderId and want a single row rather than the full history list.

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

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

No annotations provided, so description carries full burden. It explains the output format in detail (markdown rows, leg formatting, avg_fill logic) and default date window behavior. Also clarifies that avg_fill is omitted when no fills exist, which is a nuance.

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?

Well-structured with bullet points and examples, but slightly verbose with the long list of status values. Front-loaded with main purpose and output format, which aids quick comprehension.

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?

Covers date defaults, status filter enum, output format with specific examples. Output schema exists, so return values are covered. Missing context about dpop_token (likely OAuth token) and clearer description for npup (though schema says 'required'). Still reasonably complete for a retrieval 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 80%, with npup, from_date, to_date, status_filter having descriptions. The description adds significant value for from_date/to_date (explains defaults and joint usage) and status_filter (lists all valid enum values). dpop_token lacks description in both schema and text, leaving a minor gap.

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

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

The description clearly states it retrieves order history for the active Schwab account, and differentiates from siblings (e.g., 'schwab_get_brokerage_order' is singular). It gives a specific verb+resource combination with explicit output format details.

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

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

Provides clear context on date-window defaults and that both from_date and to_date should be passed together when overriding. Lists order status enum values for status_filter. Lacks explicit when-not-to-use or alternatives for related tools like schwab_get_brokerage_transactions.

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

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

With no annotations provided, the description carries the full burden and excels: it details the output format (three markdown sections), explains spread detection heuristics, covers quantity computation, and explicitly states limitations (e.g., no iron condors, butterflies, calendars). This gives the agent complete behavioral insight.

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 structured with a lead summary followed by detailed markdown. It is front-loaded with the core purpose. However, the output format examples are verbose—while informative, they could be condensed without losing clarity.

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 an output schema (which would reduce the need for return-value description), the tool provides exhaustive detail on the three output sections, spread detection logic, and limitations. For a tool with two parameters (no required), the description fully covers functionality and edge cases, earning top completeness.

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 50%, meaning one parameter (npub) has a description in the schema; the description adds value by clarifying npub is 'Required. Your Nostr public key for credit billing.' However, dpop_token is entirely unaddressed in both schema and description, leaving a gap. The baseline of 3 applies as description partially compensates.

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

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

The description clearly states the tool retrieves current positions from the active Schwab account with automatic vertical-spread detection. It uses a specific verb ('get'), a clear resource ('positions'), and adds unique functionality (spread detection) that distinguishes it from sibling tools like schwab_get_brokerage_balances.

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

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

The description implies usage for retrieving positions but does not explicitly state when to use this tool versus alternatives like schwab_get_brokerage_orders or schwab_get_brokerage_transactions. No exclusions or alternative recommendations are provided, leaving the agent to infer context from the function name alone.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It states the return format (one-line markdown) and implies it's a read operation, but does not mention idempotency, side effects, authentication requirements (beyond npub for billing), or error handling. This is adequate but not comprehensive.

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 concise (three sentences) and well-structured: it opens with the core purpose, then provides the output format, and ends with usage context. Every sentence adds value 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?

Given that the tool has an output schema (known from context), the description sufficiently explains the return format and usage scenario. It lacks mention of error cases or missing transaction IDs, but for a simple retrieval tool, it provides a solid level of completeness.

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 67% (2 out of 3 parameters have descriptions). The description adds value for transaction_id by explaining its source (activityId from get_brokerage_transactions) and for npub by clarifying its purpose for billing. However, dpop_token remains undocumented. The description does not significantly increase understanding 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 clearly states the tool retrieves full details for a single transaction by Schwab transaction ID. It specifies the verb 'get', the resource 'brokerage transaction', and distinguishes it from sibling get_brokerage_transactions by noting it returns the same one-line markdown format.

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

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

The description explains when to use this tool: when you have a specific transactionId from get_brokerage_transactions, a journal entry, or a confirmation. It implicitly contrasts with get_brokerage_transactions for scanning a history window, providing clear context without explicit 'when not to use'.

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

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

With no annotations provided, the description fully bears the burden of behavioral disclosure. It reveals the output format (markdown rows), fallback behavior when no symbols exist, date-range default logic, and valid transaction type values. However, it does not mention idempotency, authentication requirements, rate limits, or side effects, though none are expected for a read operation. It is transparent enough for safe 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?

The description is well-structured and concise. It uses a clear opening sentence, bullet points for the output row format, and separate sections for date defaults and enum values. Every sentence adds value—no fluff or redundancy. It is appropriately sized for the tool's complexity.

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 presence of an output schema (context signals say 'Has output schema: true'), the description does not need to explain return values. It covers the output format, parameter behaviors, and valid values. However, it does not mention prerequisites like OAuth session or account selection (presumably active account), which could be critical for successful invocation. Overall, it is complete for a tool with rich schema and sibling 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 schema description coverage is 80%, but the description adds significant value beyond the schema. It explains the date window default behavior (both blank = last 30 days), the exact ISO 8601 format for dates, and lists all valid transaction type values. It also clarifies that 'npub' is required despite no required array in schema, which adds important context. The description enriches the parameter understanding.

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's purpose: 'Get transaction history for the active Schwab account.' It specifies the resource (transactions) and includes detailed output format, differentiating it from siblings like 'schwab_get_brokerage_transaction' (which gets a single transaction) and 'schwab_get_brokerage_orders' (orders vs transactions). The plural name and description reinforce the 'list' nature.

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

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

While the description explains date window defaults and transaction type enum values, it does not explicitly guide when to use this tool versus alternatives such as 'schwab_get_brokerage_transaction' for a single transaction or 'schwab_get_brokerage_positions' for positions. The context is implied but not stated, leaving room for ambiguous agent 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?

No annotations, so description carries full burden. Describes output format, session emission, and that unknown market types are silently dropped. Good behavioral detail.

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?

Concise: first sentence states purpose, then code block shows output format. No redundant information. Front-loaded with key info.

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 output schema existing, description sufficiently covers behavior and parameters. Missing dpop_token description is minor. Overall adequate for invocation.

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

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

Schema coverage is 75%; descriptions in schema are detailed. Description doesn't add much beyond schema, but dpop_token lacks description. 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?

Clearly states it gets trading hours for one or more market types. Specifies output format (nested markdown). Distinct from all sibling tools, which cover accounts, orders, prices, etc.

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?

Notes that response is for a single day, implying need to pass multiple dates for multi-day forecast. Does not explicitly state when not to use, but context makes it 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It mentions the output format (markdown table) and a row limit of 20 (capped server-side), but does not disclose whether the operation is read-only, any side effects on account data, authorization requirements, or data freshness. For a data retrieval tool, this is a moderate gap.

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

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

The description is only two sentences, with the verb and resource front-loaded. Every sentence provides distinct value (purpose, output format, row limit). No excessive or redundant information. Ideal conciseness for a simple retrieval tool.

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

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

The tool has an output schema, so the description is not required to detail return values. It does mention the output is a markdown table with up to 20 rows, which is helpful. However, it lacks context on what constitutes a 'mover' (e.g., based on sort parameter), limitations on supported indices (only $SPX, $DJI, $COMPX), and how the frequency parameter affects results. Given the complexity (5 params, no annotations), the description is minimally sufficient but could be more complete.

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

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

The input schema covers 4 out of 5 parameters (80%) with descriptions, leaving only 'dpop_token' undocumented. The description does not add any parameter-specific information beyond what the schema provides. Given high schema coverage, the baseline is 3; the description adds no extra value for parameter understanding.

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

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

The description clearly states the tool retrieves 'top movers for a market index' and specifies it is 'Schwab's curated mover screener.' The verb 'Get' and resource are explicit. While there are many sibling tools, none directly compete for market movers, so differentiation is not essential. However, it could be clearer about the scope of 'top movers' (e.g., by percent change, volume, etc.), which the schema covers separately.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that Schwab's movers endpoint only supports specific indices ($SPX, $DJI, $COMPX) or that other indices will return empty lists. No exclusions, prerequisites, or comparative context with other data tools are given, leaving the agent to infer usage from the name alone.

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

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

With no annotations, the description carries full burden. It discloses that the tool is read-only, requires no authentication, returns specific metadata fields, and handles empty profiles. This provides comprehensive behavioral transparency beyond the input schema.

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

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

The description is two sentences, front-loaded with the action and resource. Every sentence adds value: the first specifies the operation, the second explains cost, authentication, and return data. 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 tool's simplicity (one optional parameter, read-only), the description covers all essential aspects: what it does, what it returns, and edge cases (empty profile). The presence of an output schema is noted, and the description complements it by listing return fields. For a retrieval tool with no side effects, this 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?

The schema has 0% description coverage, so the description must explain the parameter. It does so by stating 'Read an npub's public Nostr profile,' clarifying that the 'npub' parameter is the Nostr public key identifier. This adds sufficient meaning beyond the basic type and default in 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 clearly states the verb 'Read' and the resource 'npub's public Nostr profile (NIP-01 kind-0 metadata)', with specific details about the standard. This distinguishes it from the sibling 'schwab_publish_nostr_profile' which is for writing, making purpose unambiguous.

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

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

The description provides explicit context: 'Free, no proof — the data is already public on relays.' This tells the agent when to use it (no authentication needed, free). However, it does not explicitly state when not to use it or mention alternatives, though the sibling 'schwab_publish_nostr_profile' is a different operation, so differentiation 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?

No annotations exist, so the description carries full burden. It states the output is a Merkle inclusion proof, but does not disclose potential side effects (none expected), error cases (e.g., invalid notarization_id), or performance characteristics. The generation of a proof is implicitly safe but not clearly stated.

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, concise sentence effectively communicates the tool's purpose with no extraneous words. It is front-loaded with the core action.

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 involves a Merkle proof, a complex concept, but the existence of an output schema offloads return-value explanation. However, the description lacks context on when this proof is needed or how it relates to other tools like notarization. It is minimally adequate.

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 parameter descriptions in the schema already explain npub and notarization_id. The tool description adds no additional meaning beyond the schema, 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 uses a specific verb 'Generate' and clearly identifies the resource as a 'Merkle inclusion proof' for a patron's balance in a Bitcoin-notarized snapshot. This definitively distinguishes it from sibling tools like 'schwab_check_balance' or 'schwab_list_notarizations'.

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 explicit guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., a notarization must exist) or exclude cases where other tools might be more appropriate, such as 'schwab_list_notarizations' to find a notarization ID first.

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

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

No annotations are provided, but the description adequately explains the behavior (reporting configured/missing settings and delivery instructions). It is a read-like operation with no side effects, and the 'Free' tag suggests no cost. Could be improved by explicitly stating idempotency or safety.

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 main purpose, followed by specifics. No redundant information; every sentence adds 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?

Without parameters, the description covers what the tool does and outputs. It mentions output details (configured/missing settings, delivery instructions). Could optionally mention authentication or error handling, but not essential for this simple report.

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 are zero parameters with 100% schema coverage, so the description does not need to add param meaning. Baseline score of 4 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 it reports operator configuration readiness and distinguishes from the patron-level sibling tool. It uses specific verbs ('Report', 'Shows') and resource ('operator's configuration readiness').

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

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

Explicitly states when to use an alternative ('For patron-level credential status, use get_patron_onboarding_status instead'), providing clear guidance on tool selection.

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

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

No annotations are provided, so the description carries the full burden. It discloses the return format (markdown table, one row per leg) and that the header includes underlying price and filter constants. It does not mention authentication or side effects, but as a read operation, this is sufficient.

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 wasted words. The most important information (purpose and return format) is front-loaded. Every sentence adds 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?

Given the tool's moderate complexity and that an output schema exists, the description covers the return format and filter behavior. It could mention that the output is a markdown table for clarity, which it does. Complete enough for selection and 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 83% (high), so the baseline is 3. The description adds no extra meaning beyond the schema; it only says the output is filtered. The schema already documents parameters 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 clearly states it retrieves a filtered option chain for spread evaluation. It specifies the verb 'Get' and the resource, and the purpose is explicit. No sibling tool duplicates this function, so it's well-differentiated.

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

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

The description implies usage for spread evaluation but does not explicitly state when to use or not use this tool compared to alternatives. Since no other option chain tool exists, the guidance is adequate but not explicit.

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

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

No annotations provided, so description carries full burden. It discloses that values are never exposed, proof of npub ownership is required, and the sensitivity reasoning. Effectively communicates read-only behavior and authentication 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?

Description is efficient at 5 sentences, front-loaded with the main action ('List stored patron credential field names'). No redundant information, every sentence adds 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?

Given output schema exists, description does not need to explain return values. It covers purpose, usage, sensitivity, and auth requirements. Complete for a read-only list 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 parameter descriptions for npub and dpop_token. Description adds general context about usage (e.g., proof of ownership) but does not provide additional per-parameter details beyond the schema. 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?

Description clearly states the tool lists stored patron credential field names, not values. Verb 'list' and resource 'stored patron credential field names' are specific. It differentiates from sibling tools like update or delete by being a read-only 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?

Description explicitly says 'use this to verify which fields are configured'. Also explains the required proof of npub ownership and the sensitivity. No explicit 'when not to use' or alternative tool names, but 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?

Discloses requirement for proof of npub ownership, distinguishes service types, and notes it's free. With no annotations, it provides adequate behavioral context but misses potential error states or edge cases.

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, no fluff, front-loaded with main purpose. Efficiently conveys all necessary 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?

Given the simplicity of the tool and existence of output schema, the description covers the main scenarios. It could mention what happens if patron is not found, but overall 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 the description does not add significant detail beyond the schema. It mentions the dpop token's purpose (proof of ownership) but that is already implied by the 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?

The description clearly states it reports credential readiness for the operator, using specific verb 'Report' and resource 'credential readiness'. It distinguishes between set-once and OAuth2 services, differentiating from sibling tools like schwab_get_operator_onboarding_status.

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?

Implies use for checking patron credential readiness, but lacks explicit when-to-use or alternatives. No guidance on when not to use or comparisons to similar tools like schwab_check_oauth_status.

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

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

With no annotations, the description effectively discloses behavioral traits: returns a markdown table, caps at 30 rows, adds a footnote on truncation. It is clear about what the agent can expect, though it omits potential rate limits or authorization 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?

Three sentences with no fluff. The first sentence states purpose, the next two explain output behavior. Information is front-loaded, and every sentence adds 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?

Given complexity (7 params, output schema exists), the description covers core behavior and output constraints. It does not explain how parameters affect results, but the output schema and high schema coverage compensate. Missing guidance on default parameter 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 description coverage is 86% (high), so baseline is 3. The description adds context about output format and truncation but does not elaborate on parameter interactions (e.g., period_type and frequency_type combinations). The schema descriptions already cover parameters 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 clearly states the tool retrieves historical OHLCV candle data for a symbol, specifies the output format (markdown table capped at 30 rows), and is distinct from siblings like schwab_check_price (current price) and schwab_get_option_chain (options).

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

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

The description implies use for historical data but does not explicitly state when to use this tool versus alternatives (e.g., schwab_get_stock_quote for real-time price). It lacks guidance on parameter choice or exclusions.

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

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

With no annotations, the description carries the full burden. It discloses a side effect: self-initializes a scaffold if no model exists. It also notes the operation is free and does not involve economic data, which helps the agent understand safety and cost.

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 extremely concise: two sentences, front-loaded with the core purpose, and every word adds value. No redundancy or filler.

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

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

Given zero parameters and an existing output schema, the description covers the key aspects: purpose, side effect, cost, and data absence. It could mention output format or errors, but the output schema likely handles that. Minor gap but overall complete.

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

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

The tool has zero parameters and 100% schema coverage (empty object). The description adds meaning by explaining what the tool does without inputs, which is valuable beyond 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 it retrieves the active pricing model for the operator, distinguishing it from sibling tools like 'set_pricing_model' or 'reset_pricing_model'. The verb 'Get' and resource 'active pricing model' are specific.

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

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

The description implies this is a read-only getter, but it does not explicitly state when to use it versus alternatives like 'set_pricing_model'. No exclusion or context for choosing this tool over 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?

No annotations are provided, so the description must fully disclose behavioral traits. It only states 'real-time quotes' but omits critical details like authentication requirements, rate limits, or that unresolved symbols are silently omitted (mentioned only in schema, not description). The description lacks transparency about side effects or constraints.

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

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

The description is a single, concise sentence with no wasted words. However, it could be slightly expanded to include key behavioral notes (like silent omission of unresolvable symbols) without losing conciseness.

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 presence of an output schema and the simplicity of the tool, the description provides adequate high-level understanding. However, it lacks completeness in areas like authentication, billing (via npub), and error handling, which are important for effective use.

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

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

Schema description coverage is 67% (npub and symbols described, dpop_token lacking). The description adds no additional meaning beyond the schema; it does not explain parameter relationships or usage nuances. Baseline of 3 is appropriate since schema already covers most parameters with 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 clearly states the verb 'get', the resource 'real-time quotes', and the scope 'one or more symbols'. It unambiguously identifies the tool's purpose and distinguishes it from sibling tools like schwab_get_price_history or schwab_search_instruments.

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

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

The description does not explicitly state when to use this tool versus alternatives or provide exclusions. The usage is implied by the name and context, but there is no direct guidance on prerequisites or circumstances where other tools might be more appropriate.

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

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

With no annotations, the description carries full burden. It discloses that the tool has no side effects ('Free, no side effects') and explains the behavioral trait that tool_id stays constant while mcp_name may change. This adds value beyond the basic purpose, though it omits potential authorization or rate limit 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?

The description is very concise—six sentences with no filler. The primary purpose is stated in the first sentence, and subsequent sentences add important context efficiently.

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 low complexity (no parameters, simple list) and presence of an output schema, the description covers all necessary context: what it returns, why it exists, and its authoritative role. No gaps remain.

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 are zero parameters, and schema coverage is 100% (none needed). Baseline is 4. The description does not need to elaborate on param semantics, as there are none.

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 returns canonical identifiers (tool_id, mcp_name, …) for every registered tool, using a specific verb 'Return' and distinguishing it from siblings by framing it as the authoritative source for identity mapping.

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

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

The description explains when to use: for any client needing canonical tool identification, specifically mentioning reconciliations. While it does not explicitly list alternatives or when not to use, the context is clear and sufficient for proper 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?

No annotations are provided, so the description carries full burden. It describes the return content (type, category, description, parameter specs) and mentions it is free. No side effects are needed for a read-only listing.

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 concise with three sentences: purpose, return details, and cost. Every sentence adds value and is efficiently 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 no parameters, an output schema exists, and the description covers what the tool does, what it returns, and cost. No further context is needed for this simple listing 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?

The input schema has no parameters, so there is nothing to describe. Baseline for zero parameters is 4, and the description adds no further parameter information.

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 explicitly states 'List all available constraint types and their parameter schemas', providing a specific verb and resource. Among siblings, no other tool lists constraints, so it is well-distinguished.

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 clarifies the tool is for constraints used in a pricing pipeline and notes it is free. While it does not explicitly state when not to use it, the absence of competing sibling tools reduces the need for exclusions.

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?

Describes output fields (times_redeemed, total_uses) and ordering. Notes the restriction and proof requirement. Without annotations, it adds meaningful behavioral context, but omits details on authentication mechanism and error states.

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?

Very concise: two sentences plus a restriction note. Front-loaded with primary action and ordering. No extraneous content.

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

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

With an output schema present, the description appropriately skips return values but still adds value by explaining the progress bar use. However, lacks details on pagination, error handling, or the dpop_token parameter, which are gaps for a complete understanding.

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?

Description does not explain the single parameter dpop_token or its purpose. With 0% schema coverage, the description fails to compensate, leaving the agent to guess how to satisfy the 'requires proof' constraint.

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

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

Clearly states the tool lists every coupon the operator has minted, sorted newest first. Differentiates from sibling tools like schwab_list_my_coupons by specifying 'operator' scope.

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

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

Explicitly states the tool is RESTRICTED to the operator and requires proof, setting clear usage boundaries. However, does not mention when to use alternatives or when to avoid this tool.

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

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

With no annotations provided, the description covers key behavioral traits: it is free, requires npub proof, and returns both active and exhausted redemptions with status. However, it does not disclose potential side effects, rate limits, or that it is read-only, which could be inferred but is not explicit.

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

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

The description is three sentences, front-loaded with the core purpose, followed by details on return values and requirements. Every sentence adds value 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?

Given the tool has 2 parameters and an output schema, the description covers the basic usage and return format. It could mention that it is a read-only operation to improve completeness, but overall it provides sufficient context for an AI agent.

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

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

Schema coverage is 0%, so the description must add meaning. It provides some context for the npub parameter (requires proof), but gives no explanation for dpop_token. The description does not sufficiently compensate for the lack of 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?

The description clearly states the tool lists coupons redeemed by a specific patron on the operator, and distinguishes this from sibling tools like schwab_list_coupons that likely list all coupons. It details the return statuses, 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?

The description mentions a prerequisite (proof of npub) and that the tool is free, but does not provide explicit guidance on when to use this tool versus alternatives such as schwab_list_coupons or other listing 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?

No annotations provided, so the description carries full burden. It states 'list recent' but does not define 'recent' (e.g., time window, sorting order). No mention of read-only behavior, pagination, or scope (e.g., user-specific vs. global).

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?

Single sentence, front-loaded with the action. Efficient for a simple list tool, but could add one more sentence for usage context without losing conciseness.

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?

Output schema exists, so return values need not be described. However, the description lacks details on default ordering, scope of records, and what 'recent' means. Adequate for a simple tool but leaves ambiguity.

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 descriptions for 'limit' (Max records) and 'status' (filter). The description adds only 'recent' as context, which is implicit in the tool name. No additional parameter meaning beyond 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 'list recent Bitcoin notarization records,' which is a specific verb ('list') and resource ('Bitcoin notarization records'). It distinguishes from sibling tools like schwab_get_notarization_proof (singleton retrieval) and schwab_notarize_ledger (creation).

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 guidance on when to use this tool vs. alternatives (e.g., schwab_get_notarization_proof), nor context for filtering or ordering. The description does not mention prerequisites or exclusivity.

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

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

With no annotations provided, the description bears full burden but only says 'Create', implying mutation without details on side effects, persistence, or limitations. No behavioral traits disclosed beyond the basic action.

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

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

The description is a single efficient sentence, front-loaded with the core action. It is concise but could benefit from minimal expansion without adding much length.

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 7 parameters, no annotations, and an output schema, the description is adequate but incomplete. It lacks behavioral context, output expectations, and usage prerequisites, though the sibling tools provide some 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 high (86%), and the tool description adds no new parameter information. Baseline of 3 is appropriate since the schema does the heavy lifting, but one parameter (dpop_token) lacks 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?

The description states 'Create a new operator-owned discount coupon,' using a specific verb and resource. It distinguishes from siblings like list_coupons and update_coupon by indicating creation and operator ownership, though ownership context could be clearer.

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 guidance on when to use this tool versus alternatives (e.g., update_coupon) or prerequisites. The description does not mention any exclusion criteria or context for use.

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

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

With no annotations, the description fully discloses key behaviors: operator-only access, background execution, 1-6 hour delay, and no credit cost. It could mention whether it overwrites previous submissions or the exact output, but the given details are sufficient for safe 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 concise sentences each add distinct value: the action, the operator constraint, and practical details (time and cost). No extraneous 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 covers the tool's action, target user, duration, and cost. The only gap is the lack of information about the return value (though an output schema exists). This is minor given the tool's simplicity.

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 has no parameters (100% coverage), so the description cannot add parameter information. Baseline 3 is appropriate as there is no deficiency.

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: 'Build a Merkle tree of all patron balances and submit the root to Bitcoin via OpenTimestamps.' This clearly identifies the tool's purpose and distinguishes it from sibling tools, which focus on accounts, orders, and statements.

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 context by stating it is an 'Operator-only background task' and that 'Bitcoin confirmation takes 1-6 hours,' indicating when and how the tool should be used. It lacks explicit exclusion criteria or alternatives, but the tool's singular purpose makes that less critical.

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 only says 'Describe the DPYC ecosystem' and 'Free', with no disclosure of behavioral traits such as side effects, safety, or rate limits. No annotations are provided to supplement, leaving the agent with minimal behavioral cues.

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?

Extremely concise with two short phrases; every word earns its place. Front-loaded with the action and resource. No unnecessary information.

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

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

For a zero-parameter, simple descriptive tool with an output schema, the description is minimally complete. It defines the tool's purpose but lacks deeper context about the output or usage scenarios. Still, it meets basic needs.

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 are zero parameters, so schema documentation is trivially complete. The description adds no parameter-level meaning, but the baseline for zero-parameter tools is 4, and the description is adequate.

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 'describe' and the resource 'DPYC ecosystem via the Oracle', making the tool's purpose unambiguous and distinct from sibling tools which cover brokerage operations, OAuth, payments, etc.

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 explicit guidance on when to use this tool versus alternatives. The word 'Free' hints at no cost but doesn't provide context or exclusions. No when-not or alternative tool references.

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?

Without annotations, the description should disclose behavioral traits. It mentions the result is 'free,' but lacks details on rate limits, authentication requirements, or data freshness. For a simple 0-parameter tool, the minimal disclosure is adequate but not thorough.

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 extremely concise, front-loading the action. However, it consists of two sentence fragments, which could be more polished. It earns its place 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 zero parameters and an output schema, the description is minimal. It lacks context about what DPYC certification is or when to use this tool. For a simple getter, this may be sufficient, but completeness is only average.

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

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

The schema has no parameters, so schema coverage is 100%. The description adds no parameter-level context because none exists. 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 clearly states the tool's function: 'Get the current DPYC certification tax rate.' It uses a specific verb ('Get') and resource ('DPYC certification tax rate'), and is distinct from sibling tools like 'schwab_oracle_about' or 'schwab_oracle_lookup_member'.

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 usage guidance is provided. The description does not explain when to use this tool versus alternatives, nor does it mention prerequisites or exclusions. The word 'Free' hints at cost but does not guide decision-making.

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

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

No annotations exist, so the description carries the full burden. It implies a read-only, side-effect-free operation ('Get ... Free'). However, it does not disclose potential auth requirements, rate limits, or what happens if the user is not yet eligible for onboarding. Basic context is present but incomplete.

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

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

The description is a single, front-loaded sentence. Every word adds value: 'Get' conveys the action, 'DPYC onboarding instructions' specifies the resource, 'from the Oracle' identifies the source, and 'Free' notes a key benefit. No unnecessary 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 tool with an output schema, the description is minimally adequate. It clarifies the function but lacks explanations of key terms (DPYC, Oracle) and any edge cases. Given the simplicity, it covers the basics but misses opportunities to reduce ambiguity.

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 schema description coverage is 100%. The baseline is 3, as the description adds no parameter-specific meaning beyond what the schema already conveys. The word 'Free' is an operational note, not parameter-related.

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 'Get' and the resource 'DPYC onboarding instructions from the Oracle'. It distinguishes from siblings like schwab_oracle_about or schwab_oracle_lookup_member by specifying a concrete goal. However, the acronym 'DPYC' is unexplained, which slightly reduces clarity.

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 explicit guidance is provided on when to use this tool versus alternatives. The description does not mention any prerequisites, exclusions, or context in which this tool is preferred over other oracle or onboarding tools. This forces the agent to rely on the name alone.

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

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

No annotations are provided, so the description must convey behavioral traits. It only states 'free' but does not disclose read-only nature, required authentication, or whether the operation is destructive or idempotent.

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?

Extremely concise with only 6 words; front-loaded with the key verb and noun. However, it omits important details that could be added without significant bloat.

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 one simple parameter and an output schema, so the description does not need to explain return values. However, it lacks context about what a DPYC community member is and how the npub relates to the system, which is necessary for correct tool selection among many siblings.

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

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

Schema description coverage is 0%, and the description adds no meaning to the parameter 'npub'. It does not explain its format (e.g., hex, bech32) or the domain (Nostr public key).

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

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

The description clearly states the action ('Look up'), the resource ('DPYC community member'), and the identifier ('npub'). It distinguishes itself from sibling tools like schwab_get_nostr_profile by specifying 'community member'.

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 guidance on when to use this tool versus alternatives. The description lacks context about prerequisites, such as whether the npub must be a Nostr public key, or when to prefer this over other lookup 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?

With no annotations, the description carries full burden for behavioral traits. It only says 'Get' and 'Free', providing no details on rate limits, destructive potential, or any side effects. Minimal transparency.

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

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

The description is a single sentence, efficiently conveying the purpose. It is concise, though could include slightly more context without sacrificing brevity.

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 0 parameters and an output schema exists, reducing the need for detailed return info. However, the description lacks explanation of what 'network advisories' are or use cases, making it barely adequate.

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?

No parameters are defined in the schema, so the description adds no parameter info. Per guidelines, 0 parameters yields a baseline of 4; the description does not detract.

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

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

The description clearly states it retrieves 'active network advisories from the Oracle,' which is a specific verb and resource. This distinguishes it from sibling tools focused on accounts, balances, orders, etc.

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 guidance on when to use this tool vs. alternatives or any context about prerequisites or scenarios. The description only states its function without 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?

In the absence of annotations, the description fully discloses behavioral traits: the wheel never holds an nsec, the signature serves as authorization, no key custody is involved, and the service is free. It also specifies that the signature is verified against the npub. This provides a clear security and cost model, though it could briefly mention error handling or relay confirmation.

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 concise with five sentences, each contributing essential information. The purpose is stated first, followed by critical security and process details. There is no redundant or irrelevant content, making it easy to scan quickly.

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

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

Given the simple parameter set (2) and the presence of an output schema (not shown but present), the description covers the essential workflow, security, and cost aspects. It lacks explicit mention of error behavior or idempotency, but these are not critical for a straightforward publish operation.

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?

Both parameters have schema descriptions (100% coverage), but the description adds operational context: npub is 'the patron's Nostr public key the event must be signed by' and signed_event is 'a JSON-encoded, client-signed kind-0 event.' This reinforces their roles in the verification process, adding value 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 clearly states the verb 'Publish' and the specific resource 'CLIENT-SIGNED kind-0 profile' targeted at an npub. It distinctly differentiates from sibling tools like schwab_get_nostr_profile, which retrieves profiles, by emphasizing that this tool relays signed events to relays.

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

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

The description provides clear guidance on when to use this tool: after a client signs a kind-0 event. It also explains what the tool does not require (no nsec custody, no proof token). While it does not explicitly list alternatives or when not to use it, the context is sufficient for an agent to make an informed decision.

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

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

With no annotations, description carries full burden. Discloses: creates Lightning invoice, is free, requires proof of ownership. Does not cover multiple invoice idempotency or rate limits, but sufficient for a simple purchase tool.

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

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

Concise, front-loaded, each sentence adds value. No fluff or repetition. Efficiently conveys action, prerequisites, and post-call steps.

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 output schema exists (not shown), description doesn't need return details. Complete for a one-shot purchase action with clear follow-up (check_payment). All critical aspects 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 coverage is 100% (baseline 3). Description adds context: explains why npub proof is needed, defines dpop_token as a signed Nostr event, and clarifies amount_sats default. Adds value beyond 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?

Clearly states 'Buy credits via Bitcoin Lightning'—specific verb and resource. Distinguishes from sibling tools like 'schwab_check_payment' by outlining the full flow (invoice creation, payment, confirmation).

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 describes when to use (to purchase credits) and the required next step (call check_payment). Mentions prerequisite (proof of npub ownership). Lacks explicit when-not-to-use or alternative tools, but 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?

Without annotations, the description fully discloses behavior: deterministic one-shot retrieval, relay draining, deletion of wrong DMs, NACK of senders, acceptance of first match, stop on match, return of 'courier_not_found' on failure, and reinitialization of payment processor on success.

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?

Well-structured with a clear lead sentence, flow explanation, and detailed behavior. Slightly dense but still efficient 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 complexity (4 parameters, output schema exists), the description covers everything: purpose, usage, behavior, parameter semantics, and postconditions. No gaps remain.

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

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

Schema coverage is 100% but the description adds crucial context: explains that service, dpop_token, and sender_npub are required despite schema not marking them required, and describes the credential_card bypass behavior. It adds 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 clearly states the tool 'picks up credentials from the Secure Courier' and completes the CREDENTIAL-DELIVERY flow. It distinguishes itself from the sibling tool 'receive_npub_proof' by calling it the counterpart.

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

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

Explicitly states 'Call this only after the user confirms they have replied.' and warns 'Do NOT poll, loop, or retry.' It also contrasts with the ownership-proof flow, providing clear when-to-use 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?

With no annotations provided, the description fully discloses key behaviors: it drains only one pinned relay, stops at matching DM, deletes mismatched DMs without revealing the expected phrase, and stores a hash of the token rather than the raw token. This gives the agent complete understanding of side effects and state 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?

The description is detailed but well-organized with a clear opening statement, flow explanation, usage guidance, and behavioral notes. Each sentence contributes unique information. Slight verbosity is justified by the complexity of the tool, but could be trimmed slightly.

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 (2 parameters, output schema exists), the description adequately explains the flow, return value (dpop_token), and required app-side state management. It could mention error handling or what happens on invalid input, but overall it provides sufficient context 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 schema provides 100% description coverage for both parameters, but the tool description adds contextual meaning: it confirms that 'dpop_token' is the value returned by 'request_npub_proof' and that both parameters are required. This extra context helps the agent understand parameter origins and necessity, going slightly 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 clearly states the tool's purpose: 'Receive npub ownership confirmation from a patron.' It explicitly distinguishes from the sibling tool 'receive_credentials' by naming it and explaining that this completes the npub-OWNERSHIP-PROOF flow. The verb 'receive' and resource 'npub proof' are specific.

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

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

Provides explicit usage guidance: 'Call this only after the user confirms they have replied.' and 'Do NOT poll, loop, or retry.' It also references the prerequisite tool 'request_npub_proof' and advises against premature calling. This clearly indicates when to use and not use the tool.

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

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

No annotations provided, so description carries full burden. It discloses idempotency, no credit cost, npub requirement, validation steps, and auto-apply of discount. Lacks error handling details but sufficient.

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

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

Description is concise, front-loaded with purpose, followed by process and notes. Every sentence adds value 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?

Given 3 params, no annotations, and output schema exists, description explains core redemption flow and behaviors but omits explanation of dpop_token and does not reference output format. Adequate but gaps remain.

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

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

Schema coverage is 0%, description compensates for 'code' and 'npub' by explaining their roles, but 'dpop_token' is completely unexplained. Covers most but not all parameters.

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

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

Description clearly states 'Claim a coupon by its name' and explains the redemption process, distinguishing it from sibling tools like mint, delete, list with specific verb and resource.

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

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

Description implies when to use (to claim a coupon shared by operator) and notes free, idempotent, requires npub. Does not explicitly exclude scenarios or compare to alternatives, but context is 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?

Since no annotations are provided, the description carries full burden. It details the flow: resolves Authority endpoint, mints ownership proof, delivers MCP-to-MCP, and notes the pending state. It lacks failure modes or error handling, but the main behavior is well covered.

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

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

The description is a single paragraph that front-loads the purpose, but contains technical jargon that may reduce clarity. It is reasonably concise, though could be slightly more terse.

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 (4 parameters, output schema exists), the description is very complete. It explains the entire process, restrictions, next steps (polling), and expected state changes.

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 describes each parameter. The description does not add extra semantics per parameter beyond the overall context. 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 clearly states the tool's purpose: asking an Authority to adopt the operator. It uses the metaphor 'deferred courtship' and distinguishes from siblings like 'schwab_adoption_status' which polls for progress.

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 specifies it is restricted to the operator and requires proof of npub control. It also mentions polling 'adoption_status' for progress. However, it does not explicitly state when not to use this tool or list 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?

With no annotations, the description carries full burden. It discloses the human-in-the-loop flow (DM, manual reply), the destructive nature of receive_credentials (drains relay mailbox), and the required user confirmation. Missing details on auth or rate limits, but sufficient for the tool's behavior.

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

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

Front-loaded with main purpose, well-structured with flow labels and notes. Every sentence adds value, no wasted words. Appropriate length for the complexity.

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 human-in-the-loop complexity and interactions with sibling tools (service_status, receive_credentials, request_npub_proof), the description covers all essential steps, warnings, and post-call behavior. Output schema exists, so return values are not needed.

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

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

Schema description coverage is 100%, but the description adds extra context: service name comes from specific onboarding status tools, and sender_npub is defined. This adds value beyond the schema descriptions, justifying a score above baseline 3.

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

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

The description clearly states it opens a secure courier channel for credential delivery. It distinguishes from the sibling tool 'request_npub_proof' by specifying the credential-delivery flow vs. npub proof, and mentions that OAuth2 services don't need this, providing clear 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?

Explicitly states when to use (credential delivery) and when not to use (dynamic/OAuth2 services, advising to check service_status first). Names the alternative tool 'request_npub_proof'. Provides post-call instructions: stop, tell user, wait for confirmation, and not to poll/retry.

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

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

With no annotations, the description fully discloses behavioral traits. It explains the human-in-the-loop nature, that it does not deliver secrets, sends a challenge DM, that each receive_npub_proof call destructively drains the relay mailbox (hence no polling), returns a dpop_token that must be remembered, and the lifecycle of the cached proof. No contradictions with annotations as none exist.

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

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

The description is well-structured and front-loaded with the core purpose. Each sentence earns its place: purpose, differentiation, flow instruction, return value explanation, lifecycle. There is no redundancy or unnecessary detail.

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

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

Given the absence of annotations and the tool's relative complexity (human-in-the-loop, multi-step, return value management), the description is remarkably complete. It covers what the tool does, when to use it, how to use it in sequence with other calls, what to do with the output, and the expiration behavior. No gaps remain.

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

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

Schema description coverage is 100% for the single parameter 'patron_npub', so baseline is 3. The description in the tool description does not add significant new meaning beyond the schema's description ('Required. The patron's npub to request proof from.'). The parameter is straightforward, and the narrative mentions it in context but does not elaborate further.

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

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

The description explicitly states the tool's purpose: 'Request npub ownership proof from a patron via Nostr DM.' It clearly differentiates from the sibling tool 'request_credential_channel' by stating it does not deliver service secrets, 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?

Provides explicit usage guidance: 'use it when a call returns proof_required.' It also gives an alternative tool for different cases. The description outlines a step-by-step flow including stopping after calling and waiting for user confirmation, which is excellent guidance for when to use and what to do next.

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?

Fully discloses destructive action (delete every stored model), initialization of new model with 0 sats, and return behavior. No annotations to contradict.

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 paragraphs covering action and restriction. Efficient but could integrate parameter info.

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?

Covers main behavior and result, but omits parameter semantics. With a single optional parameter, this gap reduces completeness.

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?

Description does not mention the dpop_token parameter despite 0% schema coverage, providing no added meaning. The parameter's role is unexplained.

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

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

Description clearly states the tool erases all pricing models and restores a viable default, distinguishing it from siblings like schwab_get_pricing_model and schwab_set_pricing_model.

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

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

Explicitly states restriction to operator with required nsec-signed proof, implying usage only by authorized users, but does not explicitly contrast with alternative tools.

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