AlpineLead OI

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

Annotations already declare idempotentHint=true, destructiveHint=false, and readOnlyHint=false. The description adds the key clarification that no purchase is made, which is useful context for a configuration tool. However, it does not disclose other behavioral aspects like prerequisite conditions or side effects, so the addition is modest.

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 sentences with zero waste. The main purpose is front-loaded and the clarifying note about no purchase is immediately useful. Perfect structure for a simple configuration 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 output schema exists and annotations cover idempotency and destructiveness, the description is adequate but not complete. It fails to mention prerequisites like the authorized payment method required for enabling (though in param description) and provides no guidance on success/failure behavior. For a configuration tool with optional params, it's minimally complete.

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

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

Schema description coverage is 100%, so each parameter is well-documented in the schema itself. The description does not add any parameter-specific meaning beyond the generic 'Set Buyer Wallet limits', which adds no new value over the schema. Baseline 3 is appropriate.

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

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

The description states a clear verb ('Set') and resource ('Buyer Wallet limits'), and explicitly says 'No purchase is made by this tool', which distinguishes it from purchase actions. However, it does not differentiate from the sibling agent_buyer_wallet_setup, so the purpose is clear but sibling differentiation is missing.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives like agent_buyer_wallet_setup or agent_buyer_wallet_status. The only hint is 'No purchase is made', which implies it's not for purchasing, but there is no clear when-to-use/when-not-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?

The description transparently states that the tool does not charge or enable autonomous spending, which are key behavioral guarantees. It also implies a side effect of creating a URL. However, it does not mention potential side effects like creating a customer or payment method object, so it is not fully 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, consisting of two clear sentences that convey the essential information without superfluous detail. It is well-structured and easy to parse.

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 provides enough context for an agent to understand the tool's purpose and limitations. It does not describe the output schema, but that is not strictly necessary for selecting the tool. Slight gap: it doesn't mention what the returned URL is for or any next steps, but overall it is complete enough.

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 to describe, so the baseline of 4 applies. The description adds no parameter-related information, which is appropriate given the absence of 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 clearly states the tool's action: 'Create a Stripe Setup Checkout URL.' It also specifies the purpose (authorizing a reusable payment method) and explicitly differentiates it from charging or enabling autonomous spending, making the tool's function unambiguous.

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

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

The description explains what the tool does and what it does not do (does not charge, does not enable autonomous spending), which gives some context for when it might be appropriate. However, it does not explicitly mention alternative tools or specific scenarios for when to choose this over others, leaving some ambiguity.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds a meaningful privacy-related guarantee ('Never exposes card details or secrets') that goes beyond annotations.

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

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

Single sentence with no redundant wording. It efficiently conveys the purpose, scope, and a key safety guarantee.

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

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

Given that the tool has no parameters and has an output schema, the description sufficiently covers what the tool does, its scope, and the main reader concern (no secrets exposed). No additional context is needed.

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

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

The tool has zero parameters and schema coverage is 100%, so there is nothing to describe. The baseline for zero parameters is 4, and the description appropriately focuses on the resource being read.

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 'Read' and the resource 'authenticated user's Agent Buyer Wallet state, limits and readiness,' distinguishing it from sibling tools like agent_buyer_wallet_configure and agent_buyer_wallet_setup.

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 indicates this is for reading wallet state, limits, and readiness, and adds the important negative guarantee that it never exposes card details or secrets. It does not explicitly name alternatives, but the read-only purpose is unmistakable.

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 adds meaningful behavioral context beyond the annotations: it notes that limits are rechecked before payment and emphasizes this is a 'real' purchase, implying actual financial impact. This supplements the readOnlyHint:false and destructiveHint:true flags, though it does not address the idempotentHint.

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 and well-structured: two sentences with no redundant wording. It efficiently communicates the core action and a key safety behavior.

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

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

With an output schema present and a clear description of the action and safety checks, the description is largely complete. It does not explicitly state what the caller will receive (e.g., confirmation or error), but the output schema likely covers that, so no major gap exists.

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 descriptions cover both parameters fully (task_id and max_payment_usd). The description does not add extra meaning beyond the schema, but since coverage is 100%, the baseline of 3 is appropriate.

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

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

The description clearly states the action: 'Perform one real MPP purchase' and specifies the resource: 'authenticated user's Buyer Wallet'. This is specific and distinguishable among the many sibling tools, many of which are about quotes, checks, or other payment-related 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?

It does not explicitly state when to use this tool versus alternatives. The mention of 'Server-side task, transaction, daily and monthly limits are all rechecked' hints at safety but does not provide direct guidance on selection. It is implied that this is for executing a purchase, but not stated as a conditional.

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

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

Annotations already supply readOnlyHint, idempotentHint, and destructiveHint, so the description does not contradict them. It adds value by noting the operation is free and that it returns a budget-guarded contract without performing payment, reinforcing the non-mutating behavior.

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

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

The description is two sentences with no wasted words. It front-loads the most important facts ('Free/read-only'), then states the resource and the key negative behavior ('never performs payment itself').

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 is present, annotations cover safety semantics, and the two parameters are fully described in the schema, the description is complete for this simple read-only tool. An agent has enough context to invoke it correctly without additional explanation.

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

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

Schema description coverage is 100%, and both task_id and max_payment_usd already have meaningful schema documentation. The description's 'budget-guarded' phrasing aligns with max_payment_usd, but it does not add new parameter-level detail beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Returns a budget-guarded MPP contract,' and clarifies it is read-only. It also distinguishes itself from payment-executing siblings like fund_field_agent_task by noting it 'never performs payment itself,' though it does not name the alternatives explicitly.

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

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

The description clearly signals when to use it: when a read-only contract is needed but no payment should be executed. Phrases like 'Free/read-only' and 'It never performs payment itself' provide useful context, but there is no explicit statement of when to prefer a sibling tool for actual funding.

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

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

The description discloses a meaningful side effect: 'saves the analysis as an AGENT / API history source.' This goes beyond the annotations, which only indicate readOnlyHint=false, openWorldHint=true, and idempotentHint=false. It also states the nature of the returned intelligence. It doesn't cover cost/credit consumption, but the annotations already signal non-read-only behavior.

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

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

The description is a single, front-loaded sentence that conveys the trigger condition, the return value, and the side effect with no filler. Every clause earns its place.

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

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

For a tool with 9 parameters and a full output schema, the description gives the essential context: what triggers it, what it returns, and that it persists history. It could additionally mention whether credit consumption applies, but the schema and output schema carry much of the remaining burden.

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 input schema already documents all parameters in detail. The description adds the contextual requirement that company_name and website be known, but does not explain parameter formats or relationships beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb ('analyze') and resource (a specific company with known website) and clarifies the deliverable ('FIT / NEED / NOW opportunity intelligence'). It differentiates from broad alternatives like discover_leads and find_opportunities by requiring a known company and website, though it does not name sibling tools explicitly.

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

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

The description explicitly opens with 'Use when a specific company and website are known,' which gives a clear trigger condition. It does not mention exclusions or alternative tools by name, but the condition is specific enough to guide tool selection among the siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds value by noting the tool is free and by disclosing that it returns a resumable handoff when authentication is invalid, which is useful behavioral context beyond the annotations.

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

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

The description is a single, compact sentence that front-loads the most important information ('Free') and immediately states the core check and fallback behavior. Every word earns its place without repetition.

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

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

For a zero-parameter, read-only status check with an output schema, the description fully covers what an agent needs to know: cost, purpose, and behavior on both valid and invalid auth states. No critical guidance is missing.

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

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

The tool has zero parameters, so there is nothing for the description to explain. The schema coverage is 100% by default, and the description appropriately focuses on behavior rather than 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 ('Checks') and a clear resource ('AlpineLead authentication'), and explicitly states the outcome ('returns a resumable handoff if not'). This clearly distinguishes it from related tools like get_alpinelead_auth_handoff, which likely just retrieves a handoff rather than checking validity.

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 a preflight use case: call this before relying on AlpineLead authentication, and if invalid, use the returned handoff to resume. However, it does not explicitly state when not to use it or name alternatives, leaving some inference to the agent.

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

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

The annotations already declare the tool read-only and idempotent. The description adds valuable behavioral context beyond that: it is free, it is a polling operation, and the transition of funding_verified true can trigger automatic claiming/execution by the Nexus Factory Router. This helps the agent understand side effects and cost implications.

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

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

Two short sentences, front-loaded with the most decision-relevant fact ('Free') and immediately followed by the core action and its triggering condition. There is no filler or redundancy.

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

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

For a simple one-parameter polling tool with a full output schema and strong annotations, the description is complete enough. It communicates cost, the polling behavior, and the important downstream consequence without needing to explain return values.

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

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

The input schema already provides 100% coverage for the single required parameter, payment_id, including its purpose. The description does not add additional parameter-level detail, so the 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 a specific action ('Poll') and a specific resource ('a Field Agent payment'), so an agent can tell it deals with payment status rather than creating or funding a payment. It does not explicitly name or contrast sibling tools, but the verb and object are precise enough.

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

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

The description gives clear contextual guidance: poll until funding_verified becomes true, at which point the Nexus Factory Router may automatically claim and execute the task. It does not list alternative tools or explicit when-not-to-use cases, but the intended polling use case is evident.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the non-mutating, safe profile is clear. The description adds only optionality and the existence of an alternative, without further behavioral context like polling semantics or failure modes; this is acceptable given the strong annotation coverage.

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

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

Two short sentences with no filler. The core fact (dedicated status tool) and the main alternative are front-loaded, which is appropriately sized for a one-parameter, read-only status check.

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

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

An output schema exists and the required parameter is documented, so return values and input needs are covered. The main gap is that the description does not clarify how this tool relates to get_sales_mission_result or when to choose it over run_sales_mission, which matters given the large sibling set.

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 job_id is already fully described in the schema as 'smj_... job ID returned by start/run_sales_mission', providing 100% schema coverage. The description adds no parameter-level meaning, so the baseline of 3 applies.

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

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

Identifies itself as a status tool for AlpineLead sales missions and the title/name specify exactly what is checked. It distinguishes itself from run_sales_mission by explicitly naming that sibling's status action. The verb is implicit rather than strongly stated, so it is not a 5.

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

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

The description points to run_sales_mission(action='status', job_id=...) as an alternative, which gives the agent a decision point. However, it never states when to prefer this dedicated tool versus the alternative, such as lighter weight or simpler polling, so the guidance is implied rather than explicit.

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

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

Annotations already show the operation is not read-only, not idempotent, and not destructive. The description adds meaningful behavioral context beyond the annotations: it creates a link rather than directly charging, and explicitly states that payment requires human confirmation—preventing an agent from assuming an automated purchase.

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 short sentences with no filler. It front-loads the core action, then adds the important human-confirmation caveat. Every sentence carries necessary information.

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

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

For a simple one-parameter tool with an output schema and informative annotations, the description is sufficiently complete. It states the core purpose and a key behavioral nuance, while the required schema and output schema cover the remaining 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?

The schema already fully documents the single 'credits' parameter, including allowed values (100, 500, 2000), so the description does not need to add parameter details. With 100% schema coverage, the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Creates') and a specific resource ('Stripe checkout link for purchasing AlpineLead agent credits'). It clearly distinguishes itself from read-only credit tools like get_credit_balance and get_credit_packs by focusing on the checkout-creation action.

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 indicates this tool is for creating a Stripe checkout link when purchasing agent credits, giving the agent context on when to invoke it. It does not explicitly name alternatives or exclusion conditions, but the purchase intent is unambiguous given the sibling tools.

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

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

Annotations already indicate readOnlyHint and idempotentHint. The description adds useful behavioral context beyond annotations by stating that the metadata is 'free' and covering specific categories: capabilities, billing, and interfaces. This gives the agent a clear idea of what kind of information to expect.

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 front-loads the key attribute ('free metadata') and clearly enumerates the covered topics, making it immediately scannable for an agent.

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 information tool with an output schema and read-only annotations, this description is sufficient. It communicates the purpose, scope, and absence of cost, and the output schema can carry the detailed return structure.

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

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

The tool has zero parameters, so there is nothing for the description to document at the parameter level. The description appropriately focuses on what the tool returns rather than how to call it with arguments.

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 that the tool provides metadata about capabilities, billing, and interfaces for a specific ready-made agent. It is clear and specific about the resource and scope, but it does not explicitly differentiate itself from the sibling execution tool run_dach_company_research_agent.

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

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

Usage context is implied by the description: an agent can infer this tool is for retrieving information rather than executing the agent. However, there is no explicit guidance about when to prefer this tool over run_dach_company_research_agent or other info 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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no description.

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

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

Annotations already indicate readOnly, idempotent, and not open-world behavior. The description adds value by calling out the 'Free preflight' nature, the planned (non-executed) nature of the estimate, and its focus on budget exposure, going beyond the annotations without contradicting them.

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

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

The description is a single, front-loaded sentence that immediately states the tool's status as a free preflight and its relationship to run_sales_mission. Every word contributes to the core purpose with no filler.

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

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

The output schema and annotations cover return values and safety semantics, so the description does not need to restate those. However, given the large parameter surface and incomplete schema coverage, the description could do more to clarify how the estimate is influenced by parameters like goal and max_budget. It is adequate but has clear 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?

Schema description coverage is only 54%, leaving several parameters undocumented in the schema, but the description does little to clarify them. It references budget and credit exposure, loosely mapping to max_budget, but it adds no meaning for parameters such as tone, count, language, minimum_score, or sales_kit_count.

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 identifies the tool as a free preflight for a sales mission, with the specific purpose of showing planned maximum credit exposure and the work accomplishable within budget. It explicitly distinguishes this from run_sales_mission, making the tool's role unambiguous.

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

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

The description explicitly instructs to use this tool before run_sales_mission and explains the value it provides. It does not enumerate when not to use it or compare it with other siblings, but the primary alternative is named and the context is clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds genuinely useful behavioral context beyond those: 'Free' discloses the cost of calling, and 'Nexus credits are never treated as payment' flags an important exclusion that prevents an agent from expecting credit-based settlement. No contradiction with annotations.

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

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

Three short sentences with zero filler. The most decision-relevant fact ('Free') is front-loaded, the second sentence specifies the deliverable, and the third states a critical caveat about Nexus credits. 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?

Completeness is strong given the low complexity: one parameter, 100% schema coverage, an output schema exists, and annotations cover the read-only/idempotent/non-destructive profile. The description explains the return contents and the cost caveat. The only notable gap is the absence of routing guidance toward fund_field_agent_task, which is already accounted for in usage_guidelines.

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 task_id parameter is already well documented as 'Nexus task id to price for the matching AlpineLead Field Agent.' The description reinforces the pricing context by mentioning 'execution preflight' but adds no parameter-level meaning or format information beyond what the schema provides. Baseline 3 is appropriate.

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

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

States a specific action and resource: 'Returns Field Agent execution preflight plus traditional Stripe and native MPP payment options' clearly defines a quote/proposal operation. The title and description together distinguish it from siblings like fund_field_agent_task (execution) and check_field_agent_payment (status check), so an agent can select it without opening schemas.

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

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

No explicit when-to-use or when-not-to-use guidance is given. The description does not mention the fund_field_agent_task alternative for actually paying, nor does it state that this tool is the pre-payment step. Usage context is only implied by the word 'quote' in the name rather than stated in the description.

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 does not disclose important side effects such as saving accepted opportunities to AlpineLead CRM/history by default, potential credit consumption, or that it is a non-read-only operation. The readOnlyHint=false annotation only signals writes without specifying them.

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

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

The description is extremely concise and free of fluff. However, it is a fragment rather than a complete sentence and relies heavily on the title and schema for meaning.

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 (11 parameters, scoring, credits, history saving), the description is too thin. It does not explain what the output contains, how FIT/NEED/NOW scores are used, or when to invoke this tool instead of a more specialized sibling.

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 individual parameter descriptions are fairly detailed, so the baseline is appropriate. The description adds no extra semantic context beyond the schema, especially for how goal and offer_prompt interact.

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 name 'find_opportunities' and the phrase 'Default agent search' clearly indicate a search/find operation. The pipeline notation hints at the process, though it does not explicitly say it returns qualified opportunities.

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 says 'Default agent search' but does not explain when to prefer this tool over related siblings such as discover_leads, analyze_company, or run_sales_mission. No explicit usage conditions or alternative guidance 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?

Annotations indicate the tool is not read-only and not idempotent, but the description adds important context beyond that: it prepares a real funding route, prefers MPP mode, and states that the Field Agent will not claim or execute until Stripe confirms real payment. This meaningfully clarifies side effects and preconditions.

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

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

The description is only two sentences long, starts with the core purpose, and includes the most critical behavioral caveat right after. Every sentence earns its place with no repetition of schema or annotation 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 high schema coverage, the presence of an output schema, and the annotation set, the description covers the essential operational context: what the tool does, which mode to prefer, and when the Field Agent will act. It does not elaborate on Stripe confirmation handling, but that is not required for correct invocation.

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

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

The schema already covers all three parameters with clear descriptions, so the baseline is 3. The description adds extra parameter-level guidance by recommending MPP for autonomous agents, which reinforces and adds context to the default mode value beyond what the schema states.

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

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

The description clearly states a specific action ('Prepare a real funding route') and a specific resource ('a Nexus Field Agent task'). It also adds clarifying behavioral context (payment must confirm via Stripe before the Field Agent claims or executes), which makes the tool's role distinct from payment quote or status-checking siblings.

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

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

The description gives one useful usage hint: 'Prefer MPP for autonomous agents,' which helps select among payment modes. However, it does not explicitly explain when to use this tool versus alternatives like field_agent_payment_quote or check_field_agent_payment, leaving some routing decisions to inference.

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

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

Annotations indicate readOnlyHint=false, openWorldHint=true, and idempotentHint=false, so the tool may have side effects, but the description does not disclose what those could be (e.g., external calls, data persistence). The description adds the context of generating outreach-ready material, but does not clarify side effects or permissions. No contradiction with annotations, but limited behavioral 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 two sentences with no filler. The usage condition is front-loaded, and the purpose is stated directly. It earns its place by providing both when-to-use and what-it-does without redundancy.

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

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

Given the presence of an output schema and 100% parameter documentation, the description does not need to explain return values. However, it lacks details about side effects or costs (e.g., credit consumption), and does not mention any limitations or prerequisites beyond 'prospect analyzed.' For a tool that may write or trigger external actions (openWorldHint=true), slightly more contextual guidance 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?

Schema description coverage is 100%, so the schema fully documents each parameter. The description does not add additional semantic meaning beyond the schema, which is acceptable given the high coverage, but it also does not provide any extra context such as how website or company_name affect the output. Baseline 3 is appropriate.

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

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

Description clearly states a specific verb and resource: 'Generates structured, outreach-ready sales context.' It distinguishes itself by specifying the prerequisite (post-analysis prospect), which differentiates it from sibling tools like analyze_company or run_sales_mission, though it does not explicitly name an alternative.

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

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

The description gives explicit temporal guidance: 'Use after a prospect has been analyzed and is worth contacting.' This is a clear context, but it does not state when not to use the tool or mention any alternative tools, leaving room for more explicit exclusionary guidance.

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

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

Annotations already establish readOnly, idempotent, and non-destructive behavior. The description adds that the tool is 'Free' and returns setup instructions, which is consistent and useful. No hidden side effects are disclosed, and omission of obvious read-only behavior is acceptable given annotation coverage.

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

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

One sentence with no filler. It front-loads cost ('Free') and clearly communicates the deliverable and timing in a compact way. Every word 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 zero-parameter, read-only, idempotent tool with an output schema and rich annotations, the description fully covers what the tool does and when it should be used. Nothing essential is missing.

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

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

The tool has zero parameters and 100% schema coverage vacuously, so there is no parameter-semantic gap for the description to fill. The baseline 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 states a specific verb ('Returns') and resource ('exact authentication/setup instructions') with a clear condition ('required before a protected AlpineLead tool can run'). This clearly distinguishes it from siblings like check_alpinelead_auth, which likely verifies status rather than providing handoff instructions.

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 clearly implies when to use: before running a protected AlpineLead tool that requires authentication. It does not explicitly name alternatives or state when not to use it, but the prerequisite framing is sufficient context for an agent.

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

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

The annotations already declare readOnly, idempotent, and non-destructive behavior, so the safety profile is covered. The description adds modest useful detail by noting the output is machine-readable and that the tool is free, but it does not disclose any further behavioral traits like rate limits or output granularity.

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

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

The description is a single, front-loaded sentence that states the tool's output and purpose efficiently. The extra 'Free.' note is brief and informative, adding no unnecessary length.

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

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

Given the tool has no parameters, an output schema, and rich annotations, the description is largely complete for a simple read-only guidance packet. It could be slightly more explicit about what kind of guidance is included, but the output schema likely covers 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?

There are zero parameters and schema description coverage is 100%, so the description need not add parameter semantics. With no inputs, the tool description sufficiently explains what the call does.

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

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

The description clearly states a specific verb and resource: it returns machine-readable guidance for routing DACH B2B sales tasks to AlineLead OI. This conveys a distinct purpose, though it does not explicitly name or differentiate itself from sibling tools such as recomend_next_tool.

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

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

The phrase 'for when another AI agent should recommend or route a DACH B2B sales task to AlineLead OI' provides a clear usage context. It does not, however, mention alternatives or explicit when-not-to-use conditions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and closed-world, so safety is covered. The description adds genuinely non-annotated behavioral context: it works without authentication, making it a public/safe discovery call. It doesn't discuss rate limits, but that's minor here.

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

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

A single sentence, front-loaded with the most important cue ('Public first step'), with every clause adding distinct information. No waste, no redundancy.

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

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

For a zero-parameter discovery tool with an output schema present, the return values need not be described. The description covers purpose, auth posture, and entry-point role, which is nearly everything an agent needs; only richer routing detail is missing.

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

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

The tool takes zero parameters, so there are no parameter semantics to document; the baseline for a no-param tool is 4. Nothing in the description creates ambiguity about inputs.

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

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

The description names a specific verb (read/get) and concrete resources (capabilities, public prices, input guidance, next actions), so the agent knows exactly what it retrieves. It also frames itself as the 'public first step,' distinguishing it from the auth-gated siblings, though it doesn't name a specific alternative tool.

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

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

'Public first step' and 'without authentication' clearly signal when to reach for this tool — as an unauthenticated entry point — which is strong contextual guidance. It stops short of explicit when-not conditions or naming a sibling alternative, so it's not a full 5.

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

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

The annotations already indicate read-only, idempotent behavior, so the description does not need to repeatedly state safety. It adds meaningful context by noting the operation is scoped to the authenticated account and that both balance and usage limits are included, which goes beyond what the annotations convey.

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

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

The description is a single, focused sentence that states the core behavior without any filler. It is appropriately front-loaded and easy for an agent 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?

For a zero-parameter, read-only, idempotent tool with an output schema, the description is complete. It identifies the subject (authenticated AlpineLead account) and the returned information (credit balance and usage limits), leaving no missing inputs or side-effect ambiguity.

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

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

The tool has zero parameters in the input schema, so parameter documentation is not needed. The description adds no parameter-specific detail because there are none to document, matching the baseline expected for a no-parameter 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 identifies the operation (returns), the resource (the authenticated AlpineLead account's credit balance), and extends the title with 'usage limits,' providing precise scope. It naturally distinguishes itself from sibling tools like get_credit_packs or create_credit_checkout, which are about purchasing or listing credit products rather than reading account state.

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 intended use is clear: call this tool when you need the current account-level credit balance and usage limits. It does not explicitly name alternatives or exclusions, but the authenticated account-specific framing makes the usage context 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?

The annotations already declare readOnly, idempotent, and closed-world behavior, and the description does not contradict them. The description adds minimal behavioral context beyond that, such as the notion that the set of packages is 'available', but it does not expand on return semantics or anything the annotations do not already convey.

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

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

The description is a single front-loaded sentence with no unnecessary words. It names the verb, the resource, and the scope. Every term contributes to the agent's understanding.

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

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

For a zero-parameter read-only tool with an output schema provided, the description is fully sufficient. It identifies the resource, hints at the available state, and no additional preconditions, constraints, or collaboration guidance are necessary. An agent can reliably select and invoke this tool based solely on the description and schema.

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

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

The tool has zero parameters, so there is no parameter meaning for the description to add. The input schema is complete and relevant. The description adds no parameter detail, but none is needed. This aligns with the baseline for a 0-parameter 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 operation ('returns'), the subject (available credit packages), and the domain (AlpineLead agent). It is immediately distinguishable from the sibling tools like get_credit_balance and create_credit_checkout, both in name and stated purpose. The adjective 'available' adds useful scope.

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

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

The description transparently indicates this tool is for retrieving the list of credit packages. While it does not explicitly name alternatives or exclusion criteria, the context is clear enough for an agent to select it over related tools such as get_credit_balance or create_credit_checkout when only a read-only list is required.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, and the description reinforces read-only behavior. It adds the useful fact that the operation is free, which is not present in the annotations. The alias nature also transparently signals that behavior matches field_agent_payment_quote, providing useful context beyond structured metadata.

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 short and front-loaded: it states the alias relationship first, then the key cost and mutability traits. Every word contributes to the caller's decision, and there is no filler or redundant parameter repetition.

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

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

For a single-parameter, read-only alias with a full schema and output schema, the description covers the critical extra facts: it is free and equivalent to field_agent_payment_quote. It could be more explicit about preferring the canonical name, but nothing essential about safely invoking the tool is missing.

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

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

Schema description coverage is 100%: task_id is described as the 'Nexus task id to price for the matching AlpineLead Field Agent.' The description adds no parameter-specific detail, but with full schema coverage the baseline of 3 is appropriate; no compensation is needed.

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

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

The title 'Field Agents: get payment quote' and the tool name clearly indicate that this tool retrieves a payment quote for a field agent task. The description clarifies that it is a compatibility alias for field_agent_payment_quote, which helps distinguish it from other payment-related siblings like check_field_agent_payment and fund_field_agent_task. It does not fully state the domain action itself, relying partly on the canonical tool's name, so it stops short of a 5.

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

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

Calling this tool a 'compatibility alias' implies it exists for callers needing the old name or backward compatibility, and that field_agent_payment_quote is the canonical equivalent. However, it does not explicitly say when to choose this tool over the canonical sibling or when not to use it, leaving the routing logic mostly to inference.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering the safety profile. The description adds the scoping detail of 'current AlpineLead customer' and implies a boolean result, but does not disclose additional behaviors such as authentication requirements or error conditions. No contradiction with annotations.

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

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

A single sentence that is direct and front-loaded with the core behavior. Every word earns its place; there is no redundant or filler 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?

For a zero-parameter, read-only, idempotent status check with an output schema available, this description is fully adequate. An agent can confidently select and invoke the tool without needing additional context.

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

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

The tool has zero parameters and schema description coverage is 100%, so there are no parameter semantics to clarify. The description correctly focuses on the return meaning rather than non-existent inputs.

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 ('Returns whether') and names the exact resource state being checked: whether the current AlpineLead customer has connected HubSpot. This clearly distinguishes it from siblings like test_hubspot_connection, which implies an active connection test rather than a status 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 purpose implies usage: use this tool when you need to know whether the current customer's HubSpot integration is connected. However, it does not explicitly mention when to prefer this over test_hubspot_connection or provide any alternative guidance.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds no behavioral context beyond labeling the tool as optional and dedicated, so it contributes little beyond what annotations already 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?

Two short sentences with no filler. The key fact—this is an optional alternative to another method—is stated immediately, and the alternative invocation is provided precisely.

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 a single required parameter, an output schema, and annotations that establish safety, the description is largely sufficient. It could clarify the relationship with check_sales_mission_status, but the core information an agent needs to retrieve a mission result is present.

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

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

Schema description coverage is 100% for the only parameter, job_id, which has a clear description referencing the start/run_sales_mission return value. The description adds no additional parameter context, but the schema already carries the full semantic burden.

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 labels it as a dedicated result tool and the title mentions getting a sales mission result. It distinguishes itself from run_sales_mission by noting that the same result can be obtained via an alternative action, though it does not explicitly mention the status-checking sibling.

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 presents an alternative call path: run_sales_mission(action="result", job_id=...). This gives an agent a clear decision point between two approaches, though it stops short of stating when one should be preferred over the other or when to use status versus result tools.

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

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

Annotations already indicate idempotent and non-destructive behavior. The description adds useful behavioral context: it supports conservative, active, and aggressive modes, and enforces a hard credit cap to prevent overspending. This goes beyond the annotations and clarifies the autonomous cost guardrail.

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 high signal. The first sentence front-loads the usage condition, and the second adds key behavioral boundaries. No filler or redundancy.

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

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

For an 11-parameter configuration tool, the description is relatively brief but supported by a fully documented schema and an output schema. It captures the core decision, ongoing autonomous prospecting, and the critical safety guardrail (credit cap). It could explicitly mention persistence or relationship to hunter_run, but the provided context is largely sufficient.

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

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

Schema description coverage is 100%, so the schema fully documents all 11 parameters. The description's mention of modes and credit cap largely mirrors what is already in the schema (hunt_mode, max_credits_per_run), adding no significant extra semantic meaning. 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 configures AlpineLead OI to keep looking for opportunities over time, which is a specific verb and resource. It also distinguishes the ongoing nature of the hunter from one-off operations, though it does not explicitly name siblings like hunter_run.

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 opens with 'Use when the user wants AlpineLead OI to keep looking for new opportunities over time,' giving a clear trigger condition. It does not mention exclusions or explicitly compare against alternative tools, but the use case is well-scoped enough for an agent.

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?

Given annotations already mark this as non-read-only and non-destructive, the description adds useful behavioral detail: this is a fresh run and only accepted opportunities plus usage information are returned. It does not mention cost side effects or external actions, but with annotations carrying the safety profile plus an output schema, this is adequate.

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

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

Two tight sentences with no waste. The precondition, trigger, and return scope are all front-loaded, making the description immediately actionable.

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

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

For a tool with one optional parameter and an output schema, the description covers the essentials: prerequisite, invocation timing, and result filtering. It could briefly mention cost or external side effects, but it is not incomplete enough to confuse 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 description coverage is 100%, so the Boolean force parameter is already documented. The description does not add parameter-specific meaning, so it correctly relies on the schema for this dimension.

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

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

The description states a specific action: run an autonomous prospecting run 'now' after Hunter is configured, and clarifies the return scope ('only accepted opportunities plus usage information'). It distinguishes itself from siblings by emphasizing a fresh immediate run, though it does not explicitly name a contrasting sibling.

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

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

'Use after Hunter is configured' is an explicit precondition, and 'when the user wants a fresh autonomous prospecting run now' clearly identifies the triggering situation. It provides clear context but does not explicitly list when not to use it 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?

Annotations already declare readOnlyHint and idempotentHint, so the agent knows this is a safe, non-mutating lookup. The description adds some context by stating what is returned, but it does not disclose additional behavioral details such as caching, staleness, or data source behavior. This fits the baseline expectation for annotation-covered 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?

Very concise, front-loaded with the usage trigger, and every sentence adds meaning. No filler or repetition of schema details.

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

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

For a parameterless, read-only, idempotent retrieval tool with an output schema, the description is complete. It explains when to use it and what to expect from the response.

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 100% coverage, so no parameter-level explanation is needed. The description correctly implies the tool takes no input and simply returns the current model. This satisfies the zero-parameter baseline.

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

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

The description clearly explains the tool's purpose: it retrieves the adaptive FIT / NEED / NOW scoring model and returns personal weighting and learning confidence. It distinguishes itself by addressing a very specific query about AlpineLead OI adaptation, even though it does not explicitly name sibling tools.

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

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

The phrase 'Use when the user asks...' provides a clear condition for when to invoke the tool. It does not explicitly list when not to use alternatives, but the usage trigger is sufficiently specific to guide an agent.

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

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

Beyond the annotations (readOnlyHint, destructiveHint), the description adds valuable behavioral context: the tool is deterministic, uses 0 credits and 0 AI calls, and produces a referral/handoff ID used for conversion attribution. This gives the agent important cost and side-effect information not present in the annotations.

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

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

The description is compact and front-loaded with the most important facts: free, deterministic, use-before-workflow, returns, and handoff integration. Every sentence adds actionable information, and there is no filler or redundancy.

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

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

Given the output schema exists and annotations cover safety, the description is largely complete: it explains the output, cost, usage timing, and how to use the referral_id. It lacks only parameter-level guidance, which would have made it fully self-contained.

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

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

The schema has 0% parameter description coverage, and the description does not explain the `task`, `country`, or `industry` parameters or their expected formats. The only indirect hints are the word 'task' and the mention of DACH, which is insufficient for the agent to confidently construct the right arguments.

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 identifies the tool as a capability matcher for AlpineLead, stating the specific verb ('match'), the resource ('task to AlpineLead OI'), and the concrete outputs (whether AlpineLead can help, confidence, recommended tool, referral/handoff ID). It also positions the tool as the free pre-workflow step, distinguishing it from sibling tools like run_sales_mission or estimate_sales_mission.

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

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

The description explicitly says to use this before a paid DACH B2B opportunity workflow and instructs the agent to pass the returned referral_id when starting run_sales_mission. It gives clear contextual timing and integration steps, though it does not explicitly list alternatives or exclusion conditions.

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

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

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint, and the description adds meaningful behavioral context beyond those: no credits are consumed, no AI calls are made, and no secret material is involved. This informs an agent about cost, side effects, and auth expectations.

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

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

Two short sentences with zero filler. The core return statement is front-loaded, and 'No credits, no AI calls, no secret material' compresses three important caveats into a terse, readable clause.

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

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

For a parameterless, read-only metadata tool with an output schema, the description is nearly complete: it states what is returned and what side effects/costs are absent. It could add one sentence explaining when to prefer this over sibling discovery or A2A inspection tools, but nothing needed to invoke it correctly is missing.

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

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

The tool has zero parameters and 100% schema coverage, so there is no parameter burden for the description to carry. The zero-parameter baseline of 4 applies, and no input semantics are missing.

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 ('Return') and resource ('AlpineLead Nexus public A2A discovery locations'), and the 'public' qualifier plus 'No credits, no AI calls, no secret material' signals a lightweight metadata operation. It is distinguishable from task/agent-discovery siblings like nexus_discover_agents, though it does not explicitly name an alternative.

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

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

There is no guidance about when to call this tool versus sibling discovery tools such as nexus_discover_agents or agentpub_call_readonly_discovery_tool. The annotations imply it is safe to call, but the description does not explain the intended use context or any prerequisites.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no description.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, but the description adds meaningful context beyond them: 'Requires task-owner auth' and 'Never performs payment' are important access-control and side-effect disclosures not captured in annotations. The 'already-generated' phrasing also signals that the tool is non-blocking and does not trigger work.

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 compact: three short sentences, each carrying useful information. The core action is front-loaded, with auth and behavioral exclusions following naturally. 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 simple single-parameter read tool with a rich annotation set and an output schema available, the description is complete. It names the resource, states the auth requirement, clarifies side-effect absence, and makes its position among task lifecycle tools clear.

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

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

The input schema already includes a well-described task_id parameter with 100% coverage ('Completed Nexus task id whose stored deliverable should be read'). The description does not add parameter-specific semantics beyond what the schema provides, so the 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 states a specific verb ('Read') and a specific resource ('already-generated Field Agent result' / 'completed task deliverable'), and the title reinforces the scope as a getter for completed deliverables. This clearly distinguishes it from siblings like nexus_complete_task and nexus_find_tasks without needing to open their schemas.

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

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

The description provides clear context for when to use the tool: the result is already generated, so the tool reads rather than executes. It also gives explicit when-not behavior ('Never reruns work and never performs payment'), though it does not name alternative sibling tools directly, such as nexus_complete_task or nexus_find_tasks.

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

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

Annotations are all false, so the description carries the burden. It adds useful context that this is an immediate claim using an ephemeral Guest Pass identity, which implies auth constraints. But it does not disclose side effects of claiming, whether the claim can be undone, or failure behavior if the task is already claimed or the token expires.

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

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

A single front-loaded sentence with no filler. Every word earns its place: 'Claim' is the action, 'unpaid task' is the target, 'immediately' signals urgency, and 'ephemeral Guest Pass identity' states the authentication context.

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 two-parameter claim tool with a full schema and output schema present, the description is nearly complete. The main gap is that it does not explain how it relates to nexus_claim_task or describe the expected call sequence (start pass → claim → complete), which an agent might need when choosing among the many nexus_* siblings.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds little parameter-level detail. The description's phrase 'ephemeral Guest Pass identity' loosely reinforces the guest_token parameter, and 'unpaid task' maps to task_id, but the schema already handles the specifics.

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

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

The description states a specific verb ('Claim'), a specific resource ('an unpaid task'), and a distinctive mode ('using the ephemeral Guest Pass identity'). This makes the tool's purpose immediately clear and distinguishes it from regular nexus_claim_task, though it does not explicitly name the sibling it differs from.

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 the correct context: use when claiming an unpaid task with a Guest Pass identity. The schema reinforces this by describing guest_token as 'Short-lived token returned by nexus_guest_start_pass.' However, it never explicitly says when NOT to use this tool or when to prefer nexus_claim_task over the guest alternative.

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

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

The annotations already signal that this is a non-readonly mutation (readOnlyHint=false). The description goes beyond that by revealing a non-obvious behavioral consequence: 'Guest reputation remains non-durable until upgrade.' This is useful context not present in the schema or annotations. It does not enumerate every side effect, but it covers the most important caveat.

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 short sentences with no wasted words. The primary action is front-loaded, and the reputation caveat is delivered in a compact additional sentence. It does not restate schema fields or annotation details.

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

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

With an output schema, full parameter descriptions, and annotations available, the description is largely complete for a simple task-completion tool. It adds the key non-schema context: guest reputation durability. The only notable gap is not explaining the relationship to the closely related nexus_complete_task, which is a minor omission given the rest of the structured 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?

All four parameters have full descriptions in the schema (100% coverage), so the description does not need to repeat their semantics. The phrase 'claimed by the Guest Pass identity' hints at the relationship between guest_token and task_id, but the schema already documents these sufficiently. This matches the baseline score for a tool with complete schema coverage.

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

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

The description states a specific verb and resource: 'Complete a task claimed by the Guest Pass identity.' This clearly scopes the action to the Guest Pass flow and distinguishes it from the sibling nexus_complete_task, even though that sibling is not named. The second sentence adds a relevant consequence without clouding the core purpose.

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 establishes a clear precondition—the task must be claimed by the Guest Pass identity—and the required guest_token parameter reinforces this. However, it does not explicitly tell an agent when to prefer this tool over nexus_complete_task, nor does it mention any exclusions or alternative routes. Usage is implied rather than directly guided.

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

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

Annotations already declare read-only, idempotent, non-destrictive, and the description adds value beyond that: it discloses that the tool is public, requires zero auth, is rate-limited, and costs 0 credits and 0 AI calls. This gives an agent important operational expectations without repeating the schema. No contradiction with the annotations.

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

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

Three short sentences with no filler. The most identifying information (public, zero-auth, guest-oriented) is front-loaded, followed by the usage scenario and the operational caveats. 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 low-complexity tool with four optional parameters, an output schema, and rich annotations, the description is complete enough. It covers the key edge case (unregistered agents), auth requirements, cost, rate limiting, and read-only behavior. Nothing important is missing for an agent to decide whether to call it.

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

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

Schema description coverage is 100%, so each parameter already has a meaningful description in the schema. The tool description does not add any parameter-level nuance beyond that, but the schema carries the burder. Baseline 3 applies.

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

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

The description identifies the resource as a public, zero-auth Nexus rendezvous for guest discovery, and it is clearly tied to the tool's title. However, it lacks a strong verb like 'discover' or 'list', relying on 'rendezvous' to convey the action. It does distinguish from directory-based discovery by noting it works for agents not registered in any agent directory.

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

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

The description gives clear context: use this when you are not registered in an agent directory and still want to find or be found in Nexus. It also notes the read-only, zero-cost, rate-limited nature, which helps with cost/risk decisions. It does not explicitly name alternative tools such as nexus_discover_agents, so it falls short of full when-vs-alternative guidance.

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

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

Annotations are minimal (readOnlyHint=false, destructiveHint=false), so the description carries some burden. It discloses that the action is immediate and unpaid, which adds context beyond annotations, but it doesn't describe side effects, visibility, or pass consumption. No contradiction with annotations.

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

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

Two short sentences with no filler. The action and context are front-loaded; the paid-task caveat is a useful second sentence.

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

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

Given the output schema exists, the description covers the key distinction (unpaid vs paid) and the required flow (Guest Pass). It doesn't explain the full lifecycle, but sibling tools like nexus_guest_start_pass and the schema fill the gap.

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

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

Schema coverage is 100% and every parameter has a description, including guest_token's origin from nexus_guest_start_pass. The description adds no parameter-specific meaning, 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 uses a specific verb ('Post') and resource ('unpaid NEXUS task') with a mechanism ('Guest Pass'), and notes the contrast with paid tasks. It does not explicitly name the sibling tool (e.g., nexus_post_task) but the distinction is clear enough to route correctly.

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

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

It provides a clear condition: use this tool for unpaid tasks with a Guest Pass, and notes that paid tasks require durable authentication, implying a different path. It avoids explicit alternative tool names, but the guidance is actionable.

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

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

Annotations are all false (readOnlyHint=false, destructiveHint=false), providing no safety signals. The description adds that the identity is 'short-lived' and that it returns a token for 'unpaid task exchange', which gives the agent a clear behavioral model. It does not contradict any annotation.

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

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

The description is a single, concise sentence that immediately states the core purpose and output, with no filler. It front-loads the essential information and is easy to parse.

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

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

With an output schema present and 100% schema coverage for parameters, the description only needs to explain the tool's purpose and any non-obvious behavior. It covers the creation of a short-lived identity and the token's use, which is sufficient for an agent to call it correctly. Missing details like exact token lifetime are minor and not essential given the output schema.

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

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

Schema description coverage is 100%, with each parameter (name, markets, endpoint, description, capabilities) having a clear description in the schema. The tool description adds no extra parameter context, so the baseline of 3 is appropriate since the schema fully documents 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 ('Create') and resource ('short-lived NEXUS identity'), and explicitly clarifies it is 'without an AlpineLead account', which distinguishes it from registration tools like nexus_register_agent. It also states the output (guest_token) and purpose (unpaid task exchange), making the tool's role unambiguous among many guest and agent siblings.

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

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

The description clearly implies the context: when a guest identity is needed for unpaid tasks without an account. It does not explicitly list exclusions or alternatives, but given the sibling set, the purpose is clear. It could mention 'use nexus_register_agent for a persistent account' but it's not necessary for correct selection.

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

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

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no description.

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 explicitly warns that payout/payment fields are descriptive inputs and that payout_verified cannot be directly set, which is valuable behavioral information. It aligns with readOnlyHint=false and does not contradict annotations. It does not mention side effects beyond posting, but that is acceptable given the straightforward creation 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 very concise, using only two sentences to state the core purpose and the most important caveat. Every sentence adds value, with 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 large number of parameters, the schema-level descriptions provide most of the parameter context, and the tool description adds the critical payment caveat. Since an output schema exists, not detailing return values is acceptable. The description is slightly thin on what happens after posting, but the core context is sufficiently covered.

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

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

The schema already covers all 19 parameters with descriptions, so the baseline is high. The tool description adds meaningful semantic context by explaining that payout/payment fields are descriptive and that payment verification is server-owned, which helps distinguish informational fields from enforceable ones.

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

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

The description opens with the specific verb and resource: 'Post a Nexus task'. It also clarifies optional 'earn metadata', making the tool's primary purpose immediately obvious even among sibling task-related tools.

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

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

The description clearly indicates that this tool creates or posts a task, and the caveat about payout fields being descriptive helps prevent misuse. It does not explicitly compare against sibling tools like nexus_find_tasks or nexus_complete_task, but the verb 'post' and the context make the intended use reasonably clear.

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

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

Annotations already declare readOnly/non-destructive, and the description adds cost and side-effect context that annotations cannot express: zero-auth, zero-charge, no paid provider or model call, and no money movement. This is exactly the extra behavioral context the annotations leave out.

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?

Dense and front-loaded with the most decision-relevant fact ('DEFAULT FIRST TOOL'). The return-value enumeration is somewhat listy and partially redundant given an output schema exists, but every sentence carries usable signal.

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 9-parameter tool with an output schema, the description covers when to call, safety/cost profile, and the shape of the result. The only gap is that the optional parameters are left entirely to the schema.

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

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

Schema coverage is only 56%, and the description contributes little beyond 'Only task is required,' which merely restates the schema. It does not explain the optional fields (market, quantity, max_budget, interaction_id) that the schema leaves partly undocumented.

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

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

States a specific verb (preview) and resource (any NEXUS task), and explicitly positions itself relative to siblings: 'Call this before choosing among protected tools.' An agent can tell what this does and where it sits in the flow without opening the schema.

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

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

'DEFAULT FIRST TOOL' plus 'Call this before choosing among protected tools for a new external task' gives an unambiguous default and the triggering condition. It also explains the payoff (next.machine_next) so the agent does not need to re-choose afterward.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no description.

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

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

Annotations already declare destructive=true and idempotent=true, but the description adds genuinely useful context beyond them: acceptance unlocks seller payout eligibility, dispute freezes release, and a server-side payout flag must be enabled for an actual transfer. That precondition is real behavioral disclosure an agent could not derive from the annotations. It stops short of 5 because it says nothing about permissions or authorization.

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

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

Two tight sentences, front-loaded with the outcome the agent cares about and followed by the caveat. No filler or redundancy.

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

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

An output schema exists, so return values need not be explained, and the annotations cover the safety profile. The description supplies the key precondition and consequence, making it nearly complete; the only gap is guidance on when to invoke it relative to sibling trade 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?

Schema coverage is 100%, so the schema already documents order_id, accepted, and note in detail. The description's mapping of acceptance to payout eligibility and dispute to frozen release adds marginal meaning over the schema, but no syntax or format detail. 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 name and title state a specific verb+resource (accept or dispute delivery), and the description reinforces it by naming the buyer-side consequence (payout eligibility vs. frozen release). It implicitly distinguishes from the seller-side nexus_trade_deliver_order, though it never names that sibling. The description itself describes effects rather than the action, so a 4 rather than 5.

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

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

Usage is only implied: the description frames this as the buyer acceptance step ('Buyer acceptance...'), from which an agent can infer it follows a delivery. There is no explicit when-to-use, when-not-to-use, or routing to alternatives such as nexus_trade_deliver_order or nexus_trade_settlement_status.

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

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

Annotations already cover readOnly, idempotent, non-destructive and closed-world behavior. The description adds genuinely new context beyond them: the data is 'privacy-safe'/'observed' (aggregated/anonymized outcomes) and the call costs no payment, credits or AI invocation — useful cost and latency expectations.

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

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

Two tight sentences with zero filler; the core verb+resource lead and the cost/behavioral caveat follows. Nothing redundant with the title or 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?

An output schema exists, so return-value detail is legitimately omitted, and the annotations plus description cover safety, cost and data sensitivity. Only the routing question (why pick this over nexus_trade_capability_signals) is left unanswered for a tool with many trading siblings.

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

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

Schema description coverage is 100% with inline descriptions for market, agent_id and capability, so the schema carries parameter meaning. The description adds no extra semantics about what 'market' or 'capability' segment values look like or how the optional filters change results, so the baseline 3 applies.

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

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

States a specific verb ('Read') and resource ('observed marketplace outcomes for a Nexus seller agent'), and the title adds the 'outcome passport' framing. It is distinguishable from write-oriented trade siblings, though it never explicitly contrasts with the closest-looking read sibling, nexus_trade_capability_signals.

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

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

There is no explicit when-to-use or when-not-to-use statement, nor any named alternative. The phrase 'No payment, credits or AI call' implicitly signals a free, safe read useful for pre-trade due diligence, but an agent must infer that context on its own.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior. The description adds genuinely useful context beyond them: the data is privacy-thresholded and there is no payment, credit, or AI-call cost. It does not cover pagination or rate limits, but the output schema exists to handle return structure.

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

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

Two short sentences, front-loaded with the action and resource, followed by a clarifying cost statement. No filler; every clause earns its place.

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

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

For a low-complexity read-only tool with a fully described schema, rich annotations, and an output schema, the description covers purpose and a key behavioral fact (no cost/AI call). It is complete enough for correct invocation, though it could mention filtering intent for the optional parameters.

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