tollbooth-authority-newengland

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

With no annotations, description must cover behavior. It mentions free usage and auth requirement, but lacks details on side effects, rate limits, or error handling. Could be more transparent about what happens if npub proof is invalid.

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 short paragraphs, no fluff. Front-loaded with main purpose, followed by key constraints. 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?

Output schema exists, so return values are covered elsewhere. Description sufficiently explains scope and constraints for a tool returning multiple data types. Missing edge cases like empty history or auth failures.

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 description adds minimal extra value. It clarifies npub as patron's public key and dpop_token as a kind-27235 event, but these are already in schema descriptions. 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 it generates a patron's account statement and lists specific outputs (purchase history, credit tranches, usage breakdown, daily usage logs). It distinguishes from sibling tools like authority_account_statement_infographic and authority_check_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: free, no credits consumed, requires proof of npub ownership. Implicitly distinguishes from operator's tax balance. However, it doesn't explicitly contrast with alternatives or state when not to use this tool.

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

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

With no annotations provided, the description carries the full transparency burden. It discloses the cost and proof verification process, and hints at read-only behavior (generating a graphic). However, it does not explicitly state side effects, rate limits, or whether the tool mutates state, leaving some behavioral uncertainty.

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 four concise sentences, front-loaded with the primary purpose, followed by output details, cost, and verification. No redundant or 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?

Given the tool's moderate complexity (3 parameters, output schema exists), the description adequately covers the output format, cost, and verification. It lacks error handling or edge cases, but the presence of an output schema partially compensates. Overall sufficient for an infographic generation 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 100% coverage with descriptions for all three parameters. The tool description does not add additional parameter-level details beyond what the schema provides, so it meets the baseline without enhancing semantics.

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 generates a visual SVG infographic of an account statement, listing specific components (balance hero, metrics cards, health gauge, etc.). It distinguishes itself from the sibling tool 'authority_account_statement' by noting it returns the same data but rendered as a graphic.

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 when to use this tool (for a visual representation) versus the sibling tool for raw data. It also mentions a cost of 1 api_sat and proof verification, providing context for usage. However, it lacks explicit when-not-to-use instructions or alternatives beyond the sibling.

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

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

With no annotations, the description conveys a read-only, free operation that polls an external authority. It explicitly states 'Free' and the action 'Check', indicating non-destructive behavior, though more details on rate limits or idempotency would improve it.

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

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

The description is very concise with two sentences plus a separate line for 'Free.' It is front-loaded with the purpose and contains 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?

While the description lists possible status values and mentions output schema existence, it leaves 'dpop_token' unexplained. Given low parameter coverage, it is somewhat incomplete but sufficient for basic 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?

Schema has 0% description coverage and two parameters. The description only indirectly references 'authority_npub' via 'chosen Authority' but fails to explain 'dpop_token'. It adds minimal 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 action ('Check') and the resource ('adoption-request status') with specific status values. It distinguishes from sibling 'authority_get_adoption_status' by mentioning 'Polls the Authority MCP-to-MCP', indicating an external query.

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 checking status at a chosen authority but does not provide when-not or mention alternatives like 'authority_get_adoption_status'. It gives context but lacks explicit 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?

No annotations provided, so description carries burden. Describes the provisioning effect and consent mechanism. However, lacks disclosure of potential errors, prerequisites (e.g., existing pending request), or side effects beyond the stated 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?

Two concise sentences. Front-loaded with main action, then provides comparative context. No unnecessary words. Efficient.

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 2 params and existing output schema, description explains core behavior and usage scenario. Could mention prerequisite state (pending request) or error cases, but overall sufficient for basic 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?

Schema description coverage is 100%, baseline 3. The description adds no new parameter meaning beyond the schema's own descriptions. The contextual note about deferred consent is helpful but does not address individual 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 verb ('Approve') and resource ('pending request', 'provision the operator'). Distinguishes from sibling 'register_operator' by calling itself the 'deferred-courtship counterpart'. 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 contrasts with 'register_operator' as the deferred version used after review. Provides clear context for when to use this tool, though does not list explicit when-not-to or other 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?

No annotations are provided, so the description must cover behavioral traits. It discloses that the paid_tool decorator handles fee debit and stores cost in runtime._last_debit_cost, and that no recomputation is needed. This adds transparency about side effects and idempotency. However, it does not mention error handling or authorization requirements beyond the intended caller.

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 short paragraphs. The first sentence gives the core purpose, and the second adds essential technical context and usage guidance. No redundant or filler sentences.

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 explains the output (Schnorr-signed Nostr event certificate), specifies the caller context, and discloses side effects. With an output schema present (indicated), the description does not need to detail return values. Minor gap: the dpop_token parameter is not explained in the description, but it is in the schema.

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

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

Schema description coverage is 67% (two of three parameters have descriptions in the schema). The tool description does not add any new information about the parameters beyond what the schema already provides. Thus, it meets the baseline for high coverage but does not exceed it.

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 core action: 'Certify a purchase order: return a Schnorr-signed Nostr event certificate.' It specifies the verb (certify), resource (purchase order), and output (certificate). It distinguishes itself from the sibling 'authority_purchase_credits' by noting it is called after a purchase by operator servers.

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

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

The description clearly states when and by whom the tool is used: 'Called by operator MCP servers (not end users) when a patron purchases credits.' It also provides technical context about the paid_tool decorator and recomputation, guiding proper 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?

No annotations are provided, so the description must fully disclose behavioral traits. It indicates a check and activation, implying state mutation, but does not describe side effects, prerequisites, error conditions, or idempotency. The description is insufficient for safe use.

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 that concisely conveys the tool's role in the onboarding workflow. No redundant information is present, but it could be slightly more detailed without losing efficiency.

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 part of a multi-step process and has an output schema, the description is adequate but lacks details on the check mechanism, failure modes, and activation implications. Additional context would improve 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?

The input schema has 100% coverage with a clear description for the single parameter. The tool description adds no additional meaning beyond the schema, meeting the baseline of 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 the tool's purpose: 'Step 3/3 of Authority onboarding — check parent approval, activate Authority.' It uses a specific verb ('check') and resource ('parent approval', 'Authority'), and the step number distinguishes it from other onboarding steps.

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

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

The description provides clear context by indicating this is Step 3/3 of Authority onboarding, suggesting it should be used after previous steps. However, it does not explicitly state when not to use or name alternative 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 description carries full burden. It discloses that the tool is free and describes the consequence of zero balance. Missing details on side effects, permissions, or performance characteristics.

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, all substantive. Front-loaded with main purpose, then provides details on return value and behavior. No wasted words.

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

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

For a zero-parameter tool with an output schema, the description is complete. It explains purpose, return value, an important behavioral condition (zero balance), and ownership distinction.

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, so schema coverage is 100%. Description does not need to add parameter info. Baseline score of 4 applies.

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

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

Description uses specific verb 'check' and resource 'authority balance' clearly. It states the tool returns the operator's tax balance in sats available for certifying patron credit purchases, differentiating from sibling tools like authority_check_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?

Explains when to use: when balance reaches zero, patron top-ups cannot be certified, and operator must call purchase_credits. Clarifies it's the operator's own funding, not a patron balance. Lacks explicit exclusions 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?

With no annotations, the description adds key behavioral details: free, requires dpop token, and the reason for proof of ownership. It lacks mention of side effects or rate limits but is reasonably 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?

Two short paragraphs with front-loaded action and no unnecessary words. Every sentence provides 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 output schema exists (covers return format), the description fully covers purpose, prerequisites, and sibling distinction. No gaps identified.

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 are described in schema (100% coverage). The description adds context: dpop_token is a kind-27235 event signed by npub, and explains why it's required, enriching the semantic 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 states the tool checks a patron's credit balance, a specific verb and resource. However, it confusingly refers to using 'authority_check_balance' for operator balance, which is the same tool name, likely a typo for 'authority_check_authority_balance'. This 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?

Explicitly states when to use (patron balance) and when not (operator balance), with a clear alternative. Also provides usage conditions: free, requires proof of npub ownership.

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 only states 'look up' but does not disclose if it's read-only, requires authorization, or what happens on missing npub. Minimal behavioral context beyond the obvious.

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 with no extraneous words. Efficient but could be slightly more informative without sacrificing 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 output schema existence and tool simplicity, the description is minimally complete. However, it does not clarify return values or membership status, leaving some 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 schema has one parameter 'npub' with 0% coverage in description. The description does not explain the parameter beyond its name, missing format or example. For a simple parameter, this is insufficient.

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 action (look up) and the resource (npub in DPYC community registry). It distinguishes from sibling tools like authority_check_balance by specifying the DPYC membership context, though it does not explain what DPYC stands for.

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. There are many sibling tools with similar 'check' verbs, and no explicit differentiation or when-not-to-use advice is provided.

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

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

Discloses that no credits are required and explains the need for proof of npub ownership to prevent front-running. With no annotations provided, this adds meaningful behavioral context 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?

Three brief sentences with no wasted words. The purpose is front-loaded, and every sentence earns its place.

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

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

For a simple 3-parameter tool with output schema, the description covers when to call, what it does, and an important security note. No gaps identified.

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 new parameter details beyond what the schema already provides (e.g., invoice_id, npub, dpop_token). 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 tool checks payment status of a Lightning invoice, using a specific verb and resource. It distinguishes itself from sibling tools like authority_check_balance by focusing on payment after purchase_credits.

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 'Call after paying the invoice from purchase_credits,' providing clear when-to-use guidance. It does not mention alternatives or when not to use, but that is acceptable for a simple check 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 free usage and what is shown (base cost, discounts, surge). But lacks details on edge cases, idempotency, or side effects.

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

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

Extremely concise: two sentences front-loading the purpose and key behavioral note (free). 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?

With an output schema present, return value explanation is unnecessary. Description covers core behavior and context (preview before call, free). Could add mention of prerequisite tool_id, 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 50%. Descriptions for tool_id and tool_kwargs add meaning (resolves UUID/capability, explains pricing preview params). npub and dpop_token lack descriptions, relying only on defaults.

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 'Preview' and the resource 'effective cost of a tool call'. It distinguishes from sibling tools like authority_check_balance and authority_get_pricing_model by focusing on cost preview with constraint effects.

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?

Implied usage: use before a tool call to see cost. States 'Free — no credits required' but lacks explicit when-not or alternatives compared to sibling tools like authority_get_pricing_model.

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 fully covers behavior. Clearly states it has no side effects, does not evict cache or touch relays, and is free. This is 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?

Three concise sentences with front-loaded main action. Each sentence adds value: main purpose, usage context, behavior guarantees. 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 simple check operation and presence of output schema, the description covers purpose, usage, and behavior. It contrasts with a sibling tool. Slightly incomplete on return values but output schema handles that.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds context about dpop_token coming from request_npub_proof/receive_npub_proof, but doesn't significantly enhance parameter 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 it checks validity of a dpop_token, a specific verb+resource. It distinguishes from siblings by explicitly mirroring check_oauth_status for the npub-proof flow.

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?

Describes when to use: before a paid call to avoid burning credits on failure. Implies it's for checking token validity. Could be more explicit about when not to use compared to other check 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 provided, the description carries the full burden. It discloses that the tool verifies a DM and escalates to the parent authority, explaining how the parent is resolved. However, it does not describe side effects, success/failure behavior, or any rate limits, leaving gaps typical for unannotated tools.

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 at three lines, with the first sentence front-loading the primary purpose. The subsequent line adds necessary technical detail about parent resolution without becoming verbose, though it could be slightly more streamlined.

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 (reducing the need to explain return values), the description provides sufficient context for a tool that is part of a defined workflow. It mentions step 2/3 and how parent resolution works, but omits prerequisites (step 1) and subsequent steps, which may be acceptable for a chain of tools.

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 100% description coverage for the only parameter, candidate_npub, including its purpose. The tool description adds no further parameter details, so it meets the baseline without enhancing semantic 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's role as 'Step 2/3 of Authority onboarding — verify candidate DM, escalate to parent Authority.' This provides a specific verb (verify, escalate) and resource (Authority onboarding) that distinguishes it from sibling tools which cover various other authority operations.

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

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

The description explicitly identifies this as step 2 of a 3-step onboarding process, implying when it should be used. It does not, however, list explicit alternatives or when not to use it, but the context of a clear workflow makes this 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?

With no annotations provided, the description fully bears the burden of behavioral disclosure. It reveals important traits: cascading deletion to patron redemptions, chain steps becoming no-ops with warnings, and the restriction to operators with proof. This goes well beyond a simple 'delete' 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 two sentences long, front-loaded with the core purpose. Every sentence adds value: the first states the action, the second details cascading effects and restrictions. 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?

While the description covers behavioral consequences and authorization, it omits parameter documentation entirely. Given that the schema offers no descriptions (0% coverage) and there is no mention of output, the description feels incomplete for a tool with two parameters, one of which is non-obvious.

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%, yet the description adds no explanation for the two parameters. 'coupon_id' is somewhat self-explanatory, but 'dpop_token' (an optional token) is left completely unspecified. The description should clarify the role of dpop_token, especially since it defaults to empty.

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 begins with 'Delete a coupon' which is a clear verb+resource pair. It also explains the cascading effect on redemptions, distinguishing it from related tools like 'authority_mint_coupon' (create) and 'authority_update_coupon' (modify).

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 states 'RESTRICTED to operator — requires proof', providing a crucial usage constraint. However, it does not explicitly compare with sibling tools such as 'authority_forget_coupon' or clarify when to use this versus alternative deletion/removal 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 are present, so the description must disclose behavior. It states the operation is a write, free, requires proof of ownership, and affects only one field. This is good, but it lacks details on return values or error conditions. Adding returns or errors would make it perfect.

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

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

Three short sentences: front-loaded with purpose, then details on behavior and requirements. No unnecessary words or repetition. Highly efficient.

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 3 required params, no annotations, and many siblings, the description covers the key aspects: purpose, write nature, requirement, and scope. An output schema exists but is not shown; description does not need return values. Minor gaps: no mention of error handling or idempotency.

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 adds 'dpop_token' is a kind-27235 event, which is already in the schema. It does not provide additional meaning beyond the schema for any parameter.

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 ('Remove') and the resource ('patron credential field'). It specifies that it deletes one field without affecting others, distinguishing it from sibling tools like 'authority_update_patron_credential' (update) and 'authority_forget_credentials' (likely bulk).

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 context that proof of npub ownership is required and that this is a write to a sensitive vault. It does not explicitly list when not to use or name alternatives, but the requirement and write nature imply caution. Could be improved with explicit 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 security concern: without authority_proof, anyone with the operator's nsec could self-deregister without authority notice. However, it does not mention irreversibility or other side effects, which is acceptable but not exhaustive.

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: one sentence for purpose, one for requirement context, and a crisp bulleted list for the proofs. Every sentence adds value, and the structure is front-loaded with the primary 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?

Given no annotations and the presence of an output schema, the description covers the essential use case, requirements, and a key behavioral caveat. Missing details on dpop_token and output are minor, but overall the description is complete for a deregistration 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 describes npub and authority_proof with meaningful text, but dpop_token lacks description. The tool description adds context about the proof parameters but does not address dpop_token. Schema coverage is 67%, so the 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's purpose: 'Remove an Operator from the DPYC community registry.' It uses a specific verb ('Remove') and identifies the resource ('Operator', 'community registry'), distinguishing it from sibling tools like register_operator.

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 that the tool requires the same two proofs as register_operator and details each proof's role. It also warns about the consequence of missing authority_proof, providing implicit guidance on when not to use the tool without proper authorization.

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, but the description discloses key behavioral traits: it is cosmetic, allows re-redeem, and requires npub proof. 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 plus a line, all essential. Front-loaded with the primary action, followed by behavioral context and requirement. No waste.

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

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

Given output schema exists and limited parameters, the description covers core function and constraints. Missing param explanations slightly reduce completeness, but it's adequate for agent 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 has 3 parameters with 0% description coverage. The description only indirectly explains 'npub' as proof requirement, but does not clarify 'coupon_id' or '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 'Remove a coupon from this patron's redemption list' clearly states the verb and resource. It distinguishes from siblings like 'authority_delete_coupon' and 'authority_list_my_coupons'.

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 ('cosmetic only') and implies when not to use (for permanent deletion). However, it does not explicitly name the alternative 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, the description fully discloses that deletion requires proof of npub ownership and is as destructive as a write. This adequately warns about the operation's impact, though it could add details about reversibility or logging.

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

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

Two concise sentences: first states the purpose, second provides usage guidance. No filler, every word 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 simple operation (delete), an output schema exists, and all parameters are described with clear context, the description is complete enough for an agent to 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 coverage is 100%, so baseline is 3. The description adds context by explaining the npub role for operator vs patron and the DPoP token type (kind-27235), 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?

Description explicitly states 'Delete vaulted credentials for a specific service and npub.' This is a specific verb and resource, and it distinguishes this tool from siblings by focusing on generic credentials, not coupons or patron credentials.

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 guidance on when to use for operator vs patron credentials and stresses the requirement of npub ownership proof. It does not explicitly mention alternatives compared to siblings, 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?

The description conveys it is a read operation ('Read'), states status values, and clarifies sensitivity ('isn't sensitive'). Since no annotations are provided, this is adequate but minimal; lacks details on prerequisites or error conditions.

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 with purpose stated first, followed by status values and a remark on polling. It is relatively concise and front-loaded, though the last sentence could be slightly tighter.

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 covers purpose, status values, and safety. However, it lacks clarity on the calling context (e.g., who should use this tool vs. sibling 'authority_adoption_status'), making it somewhat incomplete 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?

The sole parameter 'operator_npub' is fully described in the input schema (100% coverage). The tool description adds no additional meaning beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description clearly states the tool reads an operator's adoption-request status, using a specific verb and resource. However, it does not explicitly distinguish from the sibling tool 'authority_adoption_status', which may serve a similar role, leaving some 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?

The description notes it is 'free, no proof' and that the operator can poll their own status via another tool, but provides no explicit guidance on when to use this tool versus alternatives like 'authority_adoption_status' or related 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 are provided, so the description must cover behavioral traits. It discloses that the operation is read-only, data is public, and returns the latest metadata fields or an empty profile. While adequate, it omits potential error cases (e.g., invalid npub) and rate limits, leaving room for improvement.

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, using two sentences. The first sentence front-loads the main action and standard, the second provides additional details about cost, proof, and return 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 tool has an output schema (context signals), the description doesn't need to elaborate return values, but it does list the specific fields returned, adding completeness. The description covers purpose, cost, auth, and data source, making it fully informative for a read 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?

With 0% schema description coverage, the description compensates by explaining the single parameter 'npub' is used to read a public Nostr profile. It adds context beyond the schema's type/string, but could be more explicit about the expected format (e.g., bech32 encoded npub).

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

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

The description clearly states the tool reads a public Nostr profile (NIP-01 kind-0 metadata) for a given npub. It specifies the verb 'read' and the resource 'public Nostr profile', and lists the expected return fields, distinguishing it from sibling tools that perform account management, notary, or other operations.

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

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

The description explicitly says it is free and requires no proof because data is already public. This guides when to use (no cost, no auth). However, it does not contrast with alternative tools for fetching profile data or specify when not to use it, but the context is clear given sibling tools are mostly different.

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 must cover behavioral traits. It does not disclose whether the operation is read-only, what happens if the notarization_id is invalid, or any failure modes. The description only states 'generate a proof' without context on side effects or 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 a single, efficient sentence that communicates the core functionality. It is front-loaded with the key action and resource, containing 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?

Given the complexity of generating a Merkle inclusion proof, the description is minimal but adequate since an output schema exists. It does not explain concepts or constraints, but for a read-like operation with good parameter descriptions, it meets the minimum threshold.

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

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

Schema coverage is 100%, so the schema already documents both parameters (npub and notarization_id). The description adds minimal extra meaning beyond mentioning 'patron's balance,' which relates to npub but does not enhance the schema definitions.

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 action: generating a Merkle inclusion proof for a patron's balance in a Bitcoin-notarized snapshot. It specifies the resource (balance, snapshot) and the verb (generate), making it distinct from sibling tools that handle other authority operations.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, conditions under which it should be invoked, or exclusions (e.g., 'use authority_check_proof_status for existing proofs').

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 the Schnorr signature gating, but does not elaborate on read-only nature, error states, or authorization details beyond the signature. With no annotations, more behavioral context would be expected.

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?

Efficient two-sentence description, front-loaded with purpose and second sentence adding the gating context without 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?

Missing key details such as how to provide the Schnorr proof (likely via dpop_token) and what constitutes valid input. The output schema exists, but invocation details are incomplete.

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 covers 50% of parameters with descriptions (npub), but the description adds no new meaning beyond the schema and fails to explain the dpop_token parameter.

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 verb 'Retrieve' and the resource 'operator bootstrap configuration (Neon URL, schema)', distinguishing it from sibling tools like authority_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?

No explicit guidance on when or when not to use this tool compared to alternatives. The description mentions a gating mechanism but does not provide 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?

No annotations provided, but the description discloses what the tool reports (configured settings, missing values, delivery instructions). It implies read-only behavior, but could explicitly state that it is non-destructive.

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, each adding distinct value: purpose, details, and sibling guidance. No wasted words, clearly front-loaded.

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

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

The description is fully adequate given zero parameters and the presence of an output schema. It covers purpose, output content, and provides a sibling reference without gaps.

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

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

With no parameters and 100% schema coverage, the description adds value by explaining the tool's purpose and output, which is sufficient for a param-less tool.

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

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

The description clearly states the verb 'Report' and the resource 'operator's configuration readiness', and explicitly distinguishes from the sibling tool 'get_patron_onboarding_status', 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 clear guidance to use 'get_patron_onboarding_status' for patron-level credential status, effectively helping the agent choose between tools. However, it does not elaborate on scenarios where this tool should not be used.

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 full disclosure burden. It clearly states that the tool is free, requires proof of npub ownership (dpop_token), and that the list itself is sensitive (revealing integrations). It also explicitly notes that values are never exposed. This goes beyond basic descriptions, though it omits potential error conditions or rate limits.

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

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

The description is concise with three well-structured sentences. The first sentence front-loads the main purpose, followed by additional context about sensitivity and requirements. No unnecessary words or information, making it easy to parse 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 tool's simplicity (2 parameters, no nested objects, output schema present), the description covers purpose, usage, behavioral traits, and parameter context adequately. It does not elaborate on return format (handled by output schema) or error handling, but what is provided is sufficient for correct invocation.

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

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

The input schema has 100% coverage with clear descriptions for both parameters (npub and dpop_token). The description does not add new parameter-level details beyond what the schema already provides; it only reiterates the sensitivity context. The baseline for high schema coverage is 3, and the description does not elevate it 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 clearly states the action 'List stored patron credential field names (not values)', with a specific verb ('list') and resource ('patron credential field names'). It distinguishes itself from sibling tools like authority_delete_patron_credential (delete) and authority_update_patron_credential (update) by focusing on read-only listing of field names.

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

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

The description explicitly says 'use this to verify which fields are configured', providing clear context for when to use the tool. It also notes the sensitivity of the list and the requirement for npub ownership proof, but does not explicitly state when not to use it or list alternatives. However, the context is sufficient for correct 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?

With no annotations provided, the description carries full burden. It discloses the required authentication (dpop_token), mentions it is free, and explains the sensitivity of credential presence. It does not mention side effects, but as a read-only check, none are expected.

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 concise paragraphs front-loaded with the main purpose. Every sentence adds necessary context without redundancy or fluff.

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 (two service types) and the presence of an output schema, the description adequately covers the needed information about credential readiness and authentication requirements.

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 the dpop_token is a kind-27235 Nostr event signed by the patron_npub, clarifying why it is needed for proof of ownership.

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 reports a patron's credential readiness for an operator, distinguishing between set-once and dynamic/OAuth2 services. This is a specific verb+resource that differentiates it from sibling tools like authority_get_patron_credential_fields.

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 the tool (to check credential readiness) and notes that proof of npub ownership is required. It does not explicitly mention when not to use it or list alternatives, but the context is clear enough for appropriate 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 exist, so the description fully carries the behavioral disclosure. It reveals the self-initialization side effect and clarifies 'No economic data from code', ensuring transparency about what the tool does and does not do.

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

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

The description is extremely concise with two sentences plus a short line. Key information is front-loaded ('Get the active pricing model for this operator. Free.') and every part 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 no parameters and the existence of an output schema, the description covers the tool's purpose, side effects, and constraints comprehensively. Nothing essential is missing.

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

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

No parameters exist, so the baseline is 4. The description adds value by explaining the self-initialization behavior and the 'Free' cost, which goes 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 verb 'Get' and resource 'active pricing model' are clearly stated. Distinguishes from sibling tools like authority_set_pricing_model and authority_reset_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?

The description states it is 'Free' and mentions self-initialization if no model exists, providing context. However, it does not explicitly instruct when to use this over alternatives, though the getter nature makes it obvious.

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. Discloses it's a list (read-only) and requires consent proof. Does not detail behavior on invalid input or rate limits, but for a read-only list this is acceptable.

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

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

Two short sentences, front-loaded purpose, no redundant words. Efficiently conveys core 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 low complexity (1 parameter, output schema exists), the description is nearly complete. It covers action, restriction, and audience. Minor omissions (e.g., what 'pending' means) are addressed 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 coverage is 100%, so description adds little beyond the schema. Schema already describes authority_proof as 'Proof signed by the Authority's OWN npub.' Description reiterates 'consent proof' but not new semantic value.

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

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

Purpose is clear: 'Owner queue: list pending operator-adoption requests.' It specifies the resource (adoption requests) and action (list pending). Distinguishes from siblings like authority_approve_adoption or authority_reject_adoption.

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 Authority owner with consent proof, providing a clear usage condition. Mentions it's the 'review-on-your-own-time surface the Pricing Studio renders,' giving context. No explicit when-not-to-use or alternatives, but the restriction is strong.

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 covers behavioral traits: it declares no side effects ('Free, no side effects') and explains the invariant behavior of tool_id versus mcp_name on renames. This is transparent and 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 front-loaded with the main purpose and uses clear, logical sentences. While it includes explanatory examples and context, every sentence adds value; however, it could be slightly more concise 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?

Given the tool's simplicity (no parameters, output schema exists), the description is fully complete. It explains the use case, the behavior on renames, and confirms no side effects, leaving no gaps for an AI agent to make mistakes.

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% trivially. The description adds no parameter detail because none are needed. Baseline for 0 params is 4, and the description meets that without requiring additional 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 clearly states the tool returns canonical identifiers for every registered tool, using specific terms like 'tool_id, mcp_name'. It distinguishes itself from sibling tools by explaining it provides the authoritative mapping, which is unique among the listed authority 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 explains that this is the authoritative source for clients needing tool identification and explicitly mentions Reconcile's use case. It implies when to use it, but does not explicitly state when not to use it or provide alternatives, though its unique purpose makes exclusion clear.

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

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

With no annotations provided, the description carries the full burden. It discloses the return fields (type, category, description, parameter specs) and the fact that it is 'Free — no credits required,' indicating no cost. This provides sufficient transparency for a read-only listing 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?

The description is extremely concise, using two brief sentences to convey purpose, return content, and cost. Every sentence adds value with no redundancy or verbosity.

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 no parameters, an output schema exists, and the description clearly states what is returned, it is fully complete for effective agent usage.

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

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

The input schema has zero parameters and schema coverage is trivially 100%. The description does not need to add parameter details, 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 clearly states the tool lists all available constraint types and their parameter schemas, using a specific verb 'List' and explicit resource. It distinguishes itself from sibling tools which are action-oriented like mint, update, or delete.

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

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

The description provides clear context: listing constraint types for a pricing pipeline, and notes it is free. It does not explicitly compare to alternatives, but no sibling tool serves the same listing function, making the usage intent unambiguous.

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

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

No annotations are provided, so the description must convey behavioral traits. It reveals that output includes a progress bar from times_redeemed vs total_uses, implying read-only behavior. However, it does not mention potential pagination, rate limits, or error conditions, leaving some gaps.

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 concise sentences, each adding unique value: purpose and ordering, output field explanation, and access restriction. No superfluous 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?

The description covers the core purpose, a key output field, and access restriction. With an output schema existing, the description does not need to list all fields. However, it lacks mention of any pagination or limits, which would be helpful for a list operation, but overall it is 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?

The schema has zero description coverage for the sole parameter dpop_token. The description mentions 'requires proof' but does not link this to the dpop_token field or explain its purpose. Given the lack of schema documentation, the description fails to compensate adequately.

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 every coupon the operator has minted, with newest first, and mentions a specific output field (times_redeemed). This distinguishes it from siblings like authority_list_my_coupons, which likely lists coupons owned by the caller rather than minted by the operator.

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 indicates the tool is restricted to the operator and requires proof, but does not contrast with sibling authority_list_my_coupons or explain when to use each. No guidance on prerequisites 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?

Discloses that it returns specific status fields and requires authentication (npub proof), but is silent on side effects, rate limits, pagination, or cost implications beyond 'Free'. Without annotations, more detail is needed.

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

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

Two concise sentences with immediate purpose and key details. No wasted words; front-loaded 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?

Provides status values and authentication note, but lacks parameter documentation and behavioral info like pagination. With an output schema present, return format is covered, but input clarity is insufficient.

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%; the description only mentions 'npub' indirectly and does not explain its format or role, and ignores dpop_token entirely. Parameters remain poorly documented.

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 coupons redeemed by the patron on this operator, specifying that it returns both active and exhausted redemptions with distinct statuses. This distinguishes it from sibling tools like authority_list_coupons.

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 for a specific patron's redeemed coupons and notes the prerequisite 'requires proof of npub'. However, it does not explicitly exclude other scenarios or compare to alternative tools like authority_list_coupons.

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 must disclose behavioral traits. It only states the action without mentioning read-only nature, authorization needs, or performance constraints. Minimal disclosure.

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 (4 words) but lacks necessary detail. It could include more context without becoming verbose. It is front-loaded but incomplete.

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 omits context about what constitutes a 'Bitcoin notarization record' and the ordering. The tool has two optional params, but the description does not indicate how they affect results. Overall incomplete relative to complexity.

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 clear parameter descriptions, so baseline is 3. The description adds no additional meaning beyond the schema, neither clarifying how 'recent' relates to sorting nor adding context for the 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?

The description uses a specific verb ('list') and identifies the resource ('Bitcoin notarization records'), making the purpose clear. However, 'recent' is vague and no timeframe is specified, reducing precision.

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 is given on when to use this tool over siblings like 'authority_get_notarization_proof' or 'authority_notarize_ledger'. No exclusions or prerequisites are mentioned.

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 full burden for behavioral transparency. It only states creation but does not disclose side effects, requirements (e.g., operator auth), or constraints (e.g., uniqueness). This leaves significant behavioral gaps.

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 short sentence with no unnecessary words, making it efficient. However, it could be slightly expanded to include critical 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?

Given the tool has 7 parameters, 4 required, and an output schema (unseen), the description is too minimal. It does not explain return values, prerequisites, or side effects, leaving the agent underinformed.

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%, so the schema already documents most parameters well. The description itself 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 clearly states the tool creates a new operator-owned discount coupon, using a specific verb ('Create') and resource ('discount coupon'), and distinguishes it from sibling tools like authority_update_coupon or authority_delete_coupon.

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 (e.g., there is no mention of not using it for updating or listing coupons). It lacks context for appropriate 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?

No annotations provided, so description carries full burden. It discloses operator-only access (auth requirement), background execution (non-blocking), Bitcoin confirmation latency, and cost (free). This adds valuable behavioral context beyond what schema or annotations would provide.

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, each delivering essential information: action, access/timeline, and cost. No redundant or unnecessary language. Exceptionally concise for the information provided.

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 no parameters and an output schema exists, the description covers all necessary context: purpose, access control, timing, and cost. It is fully adequate for an agent to decide when and how to invoke this tool.

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

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

The tool has zero parameters and schema coverage is 100%. With no parameters to document, the description correctly contains no parameter information, maintaining a baseline score of 4.

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

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

The description uses specific verbs ('Build a Merkle tree' and 'submit the root') and clearly identifies the resource ('all patron balances') and destination ('Bitcoin via OpenTimestamps'). It is distinct from all sibling tools that perform other authority operations.

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

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

States it is operator-only and a background task with 1-6 hour confirmation, providing context for when to invoke. Does not explicitly list exclusions or alternatives, but the unique purpose makes usage clear among 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?

With no annotations, the description carries full burden. It discloses that an explicit npub requires a Schnorr proof of ownership to prevent enumeration, and that empty npub skips proof check (self-inspection allowed). This is good for a read-only tool, though it omits potential error conditions or side effects.

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

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

The description is concise, with a clear first sentence and a second paragraph explaining the key behavioral nuance. It is front-loaded and efficient, though the dpop_token parameter could have been mentioned.

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 an output schema exists (inferred from context), the description effectively covers the tool's inputs, behavior, and security considerations for a simple status-viewing tool. It is complete enough for the task, though error handling is not addressed.

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 coverage is 50% (npub has a description, dpop_token does not). The description adds significant context for npub regarding proof requirements, but does not explain dpop_token at all. This partially compensates for the schema gap but leaves one parameter undocumented.

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

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

The description clearly states the tool's purpose: 'View registration status, balance summary, and the Authority's Nostr npub.' It uses a specific verb ('View') and describes the resources involved. Among many sibling tools, this uniquely identifies a read-only status inspection function.

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

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

The description provides clear context for when to use the tool, including the behavioral distinction when an explicit npub is provided vs. empty. However, it does not explicitly differentiate from sibling tools or state when not to use it, which is a minor gap.

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 implies a read-only operation with 'describe' and notes 'Free,' but does not explicitly confirm idempotency, safety, or side effects.

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

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

The description is very short with two sentences; every word serves a purpose, though 'Free.' adds marginal value. It is appropriately concise for a simple 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?

Given the tool has no parameters and an output schema exists, the description sufficiently explains what the tool does; the output schema handles return value details.

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

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

With 0 parameters, baseline 4 applies; the schema coverage is 100% trivially, and no parameter information is needed beyond what the schema provides.

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

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

The description uses a specific verb 'describe' and identifies the resource 'DPYC ecosystem', clearly distinguishing it from sibling oracle tools like authority_oracle_get_tax_rate which are more focused.

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 versus alternatives; usage is implied from the general nature but lacks explicit when-not or alternative 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?

No annotations are provided, and the description only mentions 'Free.' which is not a behavioral trait. It does not disclose side effects, permissions, or any constraints beyond being 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?

Two sentences with no wasted words. The most important information is front-loaded.

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

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

For a simple read operation with zero parameters and an output schema, the description is largely sufficient. It could optionally mention what the tax rate applies to, but it is not essential.

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, baseline 4 per instructions. The description adds meaning by specifying that the tool retrieves the tax rate and notes it is free, which adds context 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?

Clear verb+resource: 'Get the current DPYC certification tax rate.' The tool name also includes 'get_tax_rate', and it distinguishes from sibling tools that perform other actions like authority_approve_adoption or authority_certify_credits.

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 merely states 'Free.' which hints at no cost but does not provide context 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 provided, the description only adds 'Free,' which hints at no cost but does not disclose other behavioral traits such as side effects, authentication requirements, or rate limits. The tool likely is read-only, but this is not explicitly 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?

The description is very short (two sentences) and front-loaded with the purpose. However, the second sentence 'Free.' adds marginal value and could be integrated, but overall it is efficient for a simple 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?

Given the tool's simplicity (no parameters, output schema exists), the description is minimal but lacks explanation of what 'DPYC' means or what the instructions entail. This may hinder an agent's understanding without domain knowledge.

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 no parameters, and the schema coverage is 100% (empty object). According to the guidelines, 0 parameters warrants a baseline score of 4, and the description adds no parameter information 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 verb 'Get' and the resource 'DPYC onboarding instructions from the Oracle,' which is specific and distinguishes it from sibling tools like 'authority_oracle_about' or 'authority_oracle_get_tax_rate'.

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 onboarding instructions are needed, but it does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention prerequisites 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 full burden but only states it's free and a lookup. It does not disclose behavior for missing npub, rate limits, or authentication requirements, leaving significant gaps.

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 one sentence front-loading the verb and resource. The additional 'Free.' adds a useful hint about cost, though it could be integrated more 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 simple input (1 param) and presence of an output schema, the description is minimally adequate for a lookup tool. However, it lacks context about the return value or how to interpret results, leaving room for improvement.

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; the description adds only 'by npub', which is minimal. It does not explain the npub format, constraints, or expected values, failing to compensate for the missing 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 looks up a DPYC community member by npub, using a specific verb and resource. It distinguishes from sibling tools like authority_get_nostr_profile or authority_check_dpyc_membership by focusing on '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 guidance is provided on when to use this tool over alternatives, such as authority_get_nostr_profile for profile details or authority_check_dpyc_membership for membership checks. The description lacks usage context 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?

No annotations provided; description carries full burden but only says 'Get active network advisories' and 'Free'. No disclosure of side effects, data freshness, permissions, or operational 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?

Two sentences, front-loaded with action and resource. No superfluous words; ideal length for a 0-parameter 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?

Despite low complexity (no params, output schema exists), minimal description lacks behavioral context. Adequate but not comprehensive; could note non-destructive nature or data source.

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; schema coverage is 100%. Baseline 3 applies as description adds no value beyond schema for 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 verb 'Get', resource 'active network advisories', and source 'from the Oracle'. Distinct from sibling tools which cover account, authority, and other functions. 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?

No guidance on when to use vs alternatives, no exclusions or context. Only mentions 'Free' which is not usage guidance.

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

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

With no annotations provided, the description carries full burden. It discloses key behavioral traits: the wheel never holds the patron nsec, it verifies the signature against the npub, relays to public relays, and is free. No contradictions or hidden side effects are mentioned, though rate limits or error handling are omitted.

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 moderately concise (about 70 words) but includes a line break and explanatory narrative. It front-loads the action but could be tightened by removing redundant phrasing like 'no proof token, no key custody' repeated.

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

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

Given the existence of an output schema (not shown), the description adequately covers the tool's behavior: input processing, verification, and relay. It does not detail failure modes or relay success, but the output schema may handle that. For a tool with 2 parameters and moderate complexity, it is reasonably 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% for 2 parameters, so baseline is 3. The description reinforces the schema by stating that the event must be signed by the npub and that the wheel verifies the signature. It does not add significant new meaning beyond the schema descriptions.

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

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

The description clearly states the tool's purpose: publishing a client-signed kind-0 Nostr profile to relays for a given npub. It uses a specific verb (publish) and resource (profile), and differentiates from sibling tools like authority_get_nostr_profile (read) by focusing on the write/relay operation.

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

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

The description explains the context of use: when a client has a signed kind-0 event and needs to relay it. It explicitly states that no nsec is held and the signature is the authorization. However, it does not provide explicit when-not-to-use or alternative tools, though the sibling list doesn't suggest a similar 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, the description fully discloses behavior: it creates a Lightning invoice, requires proof of npub ownership for correct credit allocation, and mandates a follow-up call to check_payment. It also declares the tool is free. No destructive or side effects are mentioned, but none are expected.

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, using short sentences and a clear list structure. Every sentence adds value: purpose, flow, prerequisite, and cost. 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 tool's simplicity (3 parameters, linear workflow) and the presence of an output schema, the description covers all necessary context: process, prerequisite, and cost. It is fully adequate for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so the description adds minimal value beyond what the schema already provides for each parameter. It restates the schema descriptions for npub and dpop_token but does not add new semantic details for amount_sats beyond its default.

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 'Buy credits via Bitcoin Lightning' and outlines the specific action: creates a Lightning invoice that must be paid, then confirmed via check_payment. It distinguishes the tool from siblings by specifying the mechanism and prerequisite (npub ownership proof).

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

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

The description provides clear context on how to use the tool: create an invoice, pay it, then call check_payment. It also notes that the tool is free to call, removing cost ambiguity. However, it does not explicitly state when not to use this tool versus alternatives like mint_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 fully bears the burden. It details the verification mechanism ('inline Schnorr bound to the adoption sentinel — no relay round-trip'), records a 'pending' row, fires a DM, and explicitly states it does not provision. 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?

The description is well-structured with clear paragraphs: purpose, invocation, verification, side effects, and exclusions. Every sentence is informative and earns its place.

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

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

Given the complexity (cryptographic verification, MCP-to-MCP flow, integration with sibling tools), the description covers all essentials: preconditions, side effects, and what it does not do. An output schema exists, so return values need not be described.

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 that `dpop_token` is an inline kind-27235 proof minted automatically by `request_adoption`, providing context beyond the schema's description. Other parameters are self-explanatory.

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 'Inbound: record an operator's request to be adopted by this Authority.' The verb 'record' and resource 'operator's request' are specific. It distinguishes from the sibling `authority_approve_adoption` by explicitly noting that provisioning is not done here.

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 states 'Called MCP-to-MCP by the operator's `request_adoption`.' This provides clear guidance on when this tool is invoked. It also explains what it does not do ('Does NOT provision'), helping agents avoid misuse.

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 deterministic one-shot retrieval, draining only the rendezvous relay, deleting mismatched DMs, ACKing the correct one, and returning `courier_not_found` if no match. Also describes the `credential_card` bypass path 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 clear sections, front-loads main purpose. Almost every sentence adds value. However, it is slightly verbose; could be tightened by removing the backtick phrase about `(sender_npub, service, dpop_token)` which is already in schema.

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

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

Given the complexity and presence of an output schema (though not shown), the description covers behavior, error case (`courier_not_found`), success side effects (client reinitialized), and alternative path (credential_card). It adequately prepares an agent to use the tool correctly without further context.

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

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

Schema coverage is 100% (all 4 parameters described), baseline 3. The description adds significant context: links `dpop_token` to session phrase from `request_credential_channel`, clarifies `sender_npub`, explains optional `credential_card` bypasses relay and doesn't need `dpop_token`. This goes well 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` (ownership-proof counterpart). The verb 'pick up credentials' and resource 'Secure Courier' are specific and unambiguous.

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

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

Explicitly states when to call: 'Call this only after the user confirms they have replied.' Provides strong guidance: 'Do NOT poll, loop, or retry.' Also explains the alternative flow for `credential_card`. While it doesn't explicitly list when not to use alternatives, the 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 exist, so description carries full burden. It details deterministic one-shot retrieval, relay selection, DM matching with deletion of mismatches, and security (signed DM, token hashing). 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?

Description is detailed but every sentence provides necessary information. Front-loaded with purpose, then usage, then behavior. Slightly verbose but not wasteful.

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 covers return value (dpop_token) and flow. It fully explains the one-shot nature and constraints. Could mention error responses, but adequate overall.

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 description adds value by explaining that `dpop_token` comes from `request_npub_proof` and that parameters together identify the DM. This enhances agent understanding 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 'Receive npub ownership confirmation from a patron' and explains it completes the npub-OWNERSHIP-PROOF flow, differentiating it from sibling `receive_credentials`. It uses specific verbs and resources.

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 'Call this only after the user confirms they have replied' and warns 'Do NOT poll, loop, or retry'. Also notes the counterpart tool `receive_credentials`, providing clear when-to-use 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?

With no annotations, the description covers key behaviors: free, requires npub, idempotent, auto-applies discount, validates window and cap. It does not detail error cases or rate limits, but the main safety profile is clear.

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 but contains all necessary information without fluff. It's more verbose than minimal, but each 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?

The description covers the core functionality and constraints but does not describe the output schema (though one exists) or error scenarios. Given complexity, it lacks some detail for complete 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 description explains 'code' (the operator's coupon code) and 'npub' (requires proof), but 'dpop_token' is not mentioned. With 0% schema coverage, the description partially compensates but misses one parameter.

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 claims a coupon by its code, with specific verbs 'Claim' and detailed steps. It distinguishes from sibling tools like authority_mint_coupon or authority_list_coupons by focusing on redemption.

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 it's free, requires npub proof, and is idempotent, giving context on when to use. However, it does not explicitly state when not to use or provide alternatives among 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?

With no annotations provided, the description bears full responsibility for behavioral disclosure. It states it sends a DM, but fails to disclose side effects, idempotency, required permissions, or any state changes, leaving significant gaps for a write 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?

The description is a single sentence that conveys the essential information without any superfluous words, efficiently front-loading the purpose.

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

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

Given that an output schema exists (not shown but indicated), the description does not need to explain return values. However, for a step in a process, it could mention what happens after or implications, making it minimally complete but not rich.

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% (only one parameter fully described). The description adds no extra meaning beyond the schema's own description of the parameter, so the baseline score of 3 applies.

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

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

The description clearly states the tool's action: 'send a Nostr DM challenge to the candidate,' and identifies it as 'Step 1/3 of Authority onboarding,' which distinguishes it from sibling tools by indicating its role in a multi-step process.

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 when to use the tool ('Step 1/3 of Authority onboarding'), providing clear context for its usage. However, it does not explicitly mention when not to use it or suggest alternatives, though the step-based context implies it is the first action.

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 idempotence, required proofs, and ledger creation. Lacks explicit mention of side effects beyond creation, but adequate given output schema exists.

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

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

Well-structured with bullet points, front-loaded main action, and clear flow. No unnecessary sentences. Slightly long but earned.

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 prerequisites, identity proofs, and next step. Output schema exists so return values not needed. Lacks explicit mention of error conditions or failure modes, but overall sufficient for registration 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 75% (dpop_token missing description). Description adds meaning by linking dpop_token to the 'proof' concept and explaining authority_proof in more context. Compensates well for the 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 provisions an operator in the Authority ledger, with specific actions (purchase credits, certify orders). Distinguishes from sibling authority_deregister_operator and authority_update_operator.

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 when to use (registration) and prerequisites (two proofs). Mentions next step (purchase_credits). Does not explicitly state when not to use, but idempotent note implies safe re-call.

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 behavior. It mentions 'owner consent' via authority_proof but does not describe consequences (e.g., whether the request is removed, notifications sent, or if the action is irreversible). The behavioral impact is unclear.

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 with no wasted words. It could potentially include more context without harming conciseness, but as is, it is efficient.

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 an output schema exists and schema coverage is complete, the description is minimally adequate. However, it does not explain the purpose of 'reason', the necessity of 'authority_proof', or the result of rejection, which leaves gaps for an 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% – all three parameters (reason, operator_npub, authority_proof) have descriptions in the input schema. The description adds no additional meaning beyond the schema, so 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 verb 'Reject', the resource 'pending operator-adoption request', and the context 'owner consent'. This distinguishes it from siblings like 'authority_approve_adoption' or 'authority_request_adoption'.

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 rejecting a pending adoption request but does not explicitly state when to use it versus alternatives or provide any exclusions. It is adequate but lacks explicit 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, the description fully discloses behavior: it fixes ownership + grants, does NOT rotate password or send bootstrap DM, and is idempotent. It also explains the consequence of not using it (bootstrap aborts). 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 concise sentences: the first gives a terse action summary, the second provides context and essential exclusions. Every sentence adds value, no redundancy. Front-loaded with the core purpose.

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

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

Given no annotations but an output schema exists, the description covers all necessary behavioral context (problem, actions, non-actions, idempotency). Return values are left to the output schema, which is appropriate.

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 meaning beyond what the schema already provides for the two parameters; it merely restates them in 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?

The description starts with a clear verb phrase 'Owner repair: reassign every table... then re-grant DML' specifying the exact action and resource. It also distinguishes itself from the sibling tool 'register_operator' by explicitly stating what it does NOT do (password rotation, bootstrap DM).

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 the problem (CREATE INDEX fails due to ownership) and states that this tool fixes ownership and grants in place. It explicitly contrasts with 'register_operator' as an alternative, providing clear when-to-use and when-to-use-other 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?

No annotations provided, so description carries full burden. Details the process: mints ownership proof, delivers MCP-to-MCP, authority records pending, owner approves later. This provides sufficient behavioral context.

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

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

The description is a single paragraph but well-structured with purpose first, then constraints, then flow. It is concise without sacrificing essential 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 complexity (deferred courtship, MCP-to-MCP, inline proof), the description covers the full flow. There is an output schema present (not shown), so return values need not be explained. Mentions polling adoption_status for progress.

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

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

Schema description coverage is 100%, and the description adds meaningful context for parameters: 'operator-npub ownership proof' for dpop_token, 'this operator's MCP endpoint' for service_url, and 'npub of the Authority' for authority_npub.

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 'Ask a chosen Authority to adopt this operator' and the resource 'operator adoption'. It distinguishes from sibling tools like 'authority_adoption_status' (polling) and 'authority_approve_adoption' (approval side).

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 that the tool is RESTRICTED to the operator and requires proof of ownership. Mentions polling 'adoption_status' for progress. Does not explicitly state alternatives, 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?

No annotations exist, so description fully bears the burden. It details the human-in-the-loop flow, DM sending, manual reply requirement, and warns against polling/retrying while noting that receive_credentials destructively drains the mailbox.

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, no superfluous words. Every sentence serves a purpose, including instructions and warnings. Front-loaded with key purpose.

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

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

Given the complexity (human-in-the-loop, coordination with receive_credentials) and presence of output schema, description covers all necessary context for correct usage.

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

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

100% schema coverage, so baseline 3. Description adds context (e.g., service name from onboarding status) but does not significantly extend beyond schema descriptions. 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?

Clearly states the tool opens a Secure Courier channel for credential delivery (API keys/tokens), distinguishing it from request_npub_proof. Very specific verb+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?

Explicitly advises when to use (credential delivery) vs. when not (npub proof, dynamic/OAuth2 services) and directs to check service_status first. Also provides post-call instructions.

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 discloses the human-in-the-loop flow, challenge DM, return of dpop_token, the need to remember it, and destructive behavior of 'receive_npub_proof'. All behavioral traits are explained.

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 sections (purpose, usage, behavior, returns, lifecycle) and front-loads key information. While somewhat lengthy, each sentence adds value and the organization aids readability.

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

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

Given the tool's complexity (human-in-the-loop, dpop_token lifecycle, destructive second call), the description covers every aspect: what to do after calling, return value, token persistence, and expiration. Output schema exists but description still provides necessary workflow 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 single parameter (patron_npub) is fully described in the schema (100% coverage). The description does not add additional meaning beyond the schema, so it meets the baseline but does not exceed it.

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: requesting npub ownership proof via Nostr DM. It uses specific verb ('Request') and resource ('npub ownership proof'), and distinguishes it from sibling tools like 'request_credential_channel' by explaining the proof flow and when to use it.

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

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

The description provides explicit when-to-use guidance ('use it when a call returns proof_required'), when-not-to-use ('NOT deliver any service secret'), and directs to alternative ('use request_credential_channel'). It also includes lifecycle instructions and warns against polling/retrying.

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?

Description discloses the destructive action of deleting all stored models and then initializing a fresh one. It also mentions the return of the new model and the restricted access requirement. Without annotations, this provides adequate behavioral 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?

Description is extremely concise with four sentences. It front-loads the main action and then provides supporting details. Every sentence earns its place with no redundancy.

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

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

Given the tool's simplicity (one optional parameter, output schema expected), the description covers the operation, access restriction, and return value. It is complete for the reset action, though it could mention the consequences for ongoing operations.

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 one optional parameter (dpop_token) with a default empty string. The description mentions 'requires proof (nsec-signed)' which hints at authentication but does not directly explain the dpop_token parameter. With 0% schema coverage, the description adds minimal meaning beyond the schema, but the tool is simple enough that this is acceptable.

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

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

Description clearly states the verb 'erase' and 'restore' with the resource 'all pricing models' and 'a viable default'. It distinguishes from siblings like authority_set_pricing_model which sets a custom model, and authority_get_pricing_model which retrieves the current 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?

Description specifies that this tool is restricted to operators and requires proof, providing context on who should use it. However, it does not explicitly contrast with alternatives like authority_set_pricing_model for when a custom model is needed, nor does it state when not to use this tool.

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

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

No annotations provided, so description carries full burden. Discloses idempotency and authentication requirement (dpop_token). However, does not describe error handling or side effects beyond idempotency. Could be more explicit about what happens on failure.

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 (restriction, use cases, idempotency). Front-loaded with main action. No wasted sentences; 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 (3 params, output schema exists), the description covers purpose, usage context, authentication, and idempotency. Does not explain return values, but output schema is present. Minor gap in error conditions.

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 meaningful context for 'dpop_token' (kind-27235 Nostr event, operator-only). For the other parameters, it reuses schema descriptions but provides overall context. 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?

The description clearly states the verb 'credit' and the specific resource 'patron's ledger from a BTCPay-settled invoice.' It distinguishes from siblings by specifying a unique use case, and the title is not provided but the description itself is 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?

Explicitly states it is restricted to the operator and describes specific use cases (cold-start vault races, ncred delivery hiccups, etc.). Provides clear escalation path for patrons. Does not explicitly compare to sibling tools, 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.