AlpineLead OI

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

Annotations already declare readOnly, idempotent, and non-destructive behavior, so the description adds meaningful context by explicitly stating it does not reveal the key. This is a valuable non-obvious behavioral guarantee that complements the annotations and reassures agents handling sensitive configuration.

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. The primary purpose is delivered in the first sentence, and the critical safety caveat about not revealing the key follows immediately. 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 status tool with a full output schema and complete annotations, the description covers everything an agent needs: what it checks, that it is safe, and the key privacy guarantee. No return-value explanation is required given the output schema presence.

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 semantics to convey. The description correctly focuses on the behavior rather than inputs, and the baseline of 4 for parameterless tools applies here.

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

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

The description uses a specific verb ('Check') and names the exact resource ('AgentPub bridge secret') and the condition being tested (whether it is configured). It clearly distinguishes itself from other status tools in the sibling list by focusing on the AgentPub bridge secret specifically.

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 its use case: checking the AgentPub bridge secret configuration before relying on AgentPub functionality. However, it does not explicitly state when to use this tool versus alternative status checks like check_sales_mission_status or get_hubspot_status, nor does it mention any exclusions or 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the passthrough behavior and the rationale about preserving native parameters, which is a meaningful behavioral trait. It does not discuss error propagation or unknown-argument behavior, but the annotation coverage lowers that burden.

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 no filler. The first sentence front-loads the purpose, and the second provides the rationale for existing. Every word contributes value, and the description is easy to parse in one pass.

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 passthrough tool, the description, combined with full schema coverage and an output schema, is sufficient. It covers what the tool does, why it exists, and the dynamic-arg caution via the arguments parameter. It slightly under-specifies how to discover the live schema, but the sibling inspection tools fill that 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?

With schema_description_coverage at 100%, the input schema already documents both tool_name and arguments, including the list of allowed tools and the instruction to inspect the live schema. The description itself adds no parameter-level meaning, so it hits the baseline for high 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 clearly states this is a 'Safe passthrough for AgentPub read-only discovery primitives,' identifying both the verb (passthrough/call) and the resource class (read-only discovery primitives). It implicitly differentiates from sibling schema-inspection tools like agentpub_inspect_discovery_schemas, though it does not list the concrete native tools in the description itself—that detail lives in the tool_name parameter 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?

The description gives useful context: use this passthrough when AgentPub publishes incomplete formal schemas, to avoid losing native parameters. However, it does not explicitly name alternative tools or state when not to use it, leaving the agent to infer from sibling names like agentpub_inspect_remote_tool_schema that there are other routes.

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 communicate that this is a mutating, non-idempotent operation. The description adds a useful upstream quirk: 'kind is forwarded explicitly because AgentPub's live create_channel schema requires it.' It does not disclose failure modes, duplicate behavior, or side effects on existing channels, but the annotation profile covers the basic safety 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?

The description is exactly two well-structured sentences. The main purpose is front-loaded, and the second sentence earns its place by explaining a non-obvious upstream requirement. No filler or redundant restatement of the schema.

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

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

For a straightforward create operation with a full input schema, an output schema, and safety annotations, the description is largely sufficient. It captures the key quirk of the upstream API and the relevant domain usage. It does not offer cross-sibling routing or failure expectations, but those are not essential given the schema and annotation coverage.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds domain-specific semantics beyond the schema by tying the kind parameter to AlpineLead Nexus community rooms, and it explains why kind must be forwarded even though the schema has a default. This extra context meaningfully improves parameter understanding.

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

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

The description opens with a specific verb and resource: 'Create an AgentPub channel.' This clearly separates it from sibling tools like agentpub_join_channel, agentpub_list_channels, and agentpub_send_channel_message. The second sentence adds relevant detail about the kind field without obscuring 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?

Usage is mostly implied by the verb 'Create': the tool is for creating a channel. It provides concrete guidance for the kind parameter ('For AlpineLead Nexus community rooms use kind="group"'), but it never mentions when not to use this tool or how it compares to sibling actions such as joining or inviting to a channel.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is well covered. The description adds a meaningful behavioral promise beyond annotations: 'Never reveals AGENTPUB_API_KEY', plus the diagnostic/read-only framing, which helps an agent understand side-effect and secrecy 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 compact sentences front-load the core purpose and then add the essential diagnostic and security caveats. Every sentence earns its place with no redundancy or filler.

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

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

For a 0-parameter, read-only, idempotent introspection tool with an output schema, the description fully equips an agent: it names the target, states the diagnostic use case, and flags the secret-handling constraint. No critical behavioral or invocation 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?

This tool has zero parameters, so the schema trivially covers the entire interface. The description adds context about what objects are inspected (live native MCP descriptions/input schemas), which is useful even though no parameter documentation 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?

States a specific verb ('Inspect') and resource: AgentPub's live native MCP descriptions/input schemas for discovery-related tools. It clearly distinguishes itself from the sibling agentpub_inspect_remote_tool_schema by scoping to live native schemas and discovery-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?

Gives clear context: use this when you need to inspect live native MCP schemas for discovery tools, and labels it as diagnostic/read-only. It does not explicitly name alternatives such as agentpub_inspect_remote_tool_schema or explain when to prefer one over the other, so a small gap remains.

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 safety profile is covered. The description adds meaningful extra context beyond annotations by promising that the API key is never exposed, which is valuable for an agent deciding whether this tool is safe to invoke.

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, no filler. The core purpose is front-loaded and the safety note earns its place by adding a constraint an agent should know before invoking the 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?

For a single-parameter diagnostic tool with full schema coverage, rich annotations, and an output schema, the description is complete. It explains what the tool reads, that it is diagnostic only, and that it preserves API key confidentiality.

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 single parameter tool_name already has a clear description with an example. The tool description does not add parameter-level meaning, but with full schema coverage, 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 action and resource: reading the live AgentPub MCP tools/list schema for one native AgentPub tool. The phrase 'diagnostic only' further distinguishes it from the many functional sibling tools, so an agent can tell what it does without inspecting 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?

The description gives clear context: this is a diagnostic operation and never exposes the API key. It does not explicitly name alternative tools or state when not to use it, but the 'diagnostic only' framing strongly implies its narrow purpose 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 indicate this is a mutating, non-idempotent operation. The description adds meaningful behavioral context by clarifying that the action is only a message send and does not auto-register or execute work, which prevents false assumptions about downstream side effects.

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

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

The description is two concise sentences with no filler. The primary action is front-loaded, and the crucial limitation is stated immediately after, making it 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 simple two-parameter tool with a full schema and annotations, the description covers the necessary behavioral and scoping details. It could slightly expand on what 'standard Nexus invitation' entails or what happens for unknown recipients, but the existing output schema and annotations cover the remaining essential context.

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

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

Schema description coverage is 100%, so both parameters are already documented. The description does not add new parameter-level detail, but it aligns with the schema by framing the action as an invitation, which is sufficient given the complete schema.

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

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

The description names a specific action ('Send the standard AlpineLead Nexus invitation') and a specific recipient class ('known AgentPub agent'). The caveat that it only sends a message and does not register or execute work clearly differentiates it from related tools like nexus_register_agent or execution-oriented 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 gives clear scope: use for sending an invitation to a known AgentPub agent. The second sentence explicitly states what the tool does not do, providing a useful when-not-to-use boundary, though it does not name sibling tools as alternatives.

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

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

While annotations already indicate readOnlyHint=false, idempotentHint=true, and destructiveHint=false, the description adds no extra behavioral context such as membership effects, invitation requirements, or what happens if the channel is already joined. For a mutating operation, this is minimal.

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 one concise, front-loaded sentence with no filler. 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 simple one-parameter join tool, the description and annotations cover the core usage and safety profile. However, it doesn't mention how to discover a valid channel ID (e.g., via list_channels) or any prerequisite (e.g., invite-only), which is a minor gap.

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

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

The input schema already provides 100% coverage with a clear parameter description. The tool description only repeats 'by channel ID' and adds no additional semantic meaning such as where to find the ID or format constraints.

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 ('join'), a target resource ('existing AgentPub group channel'), and the input condition ('by channel ID'). It clearly conveys the tool's function and differentiates from create/leave siblings by saying 'existing', though it does not explicitly contrast with them.

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 on when to use this tool versus alternatives like agentpub_create_channel, agentpub_leave_channel, or agentpub_list_channels. No prerequisites, exclusions, or 'use this when ...' hints are 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?

The annotations already mark the tool as destructive and not read-only, so the agent knows this is a mutating action. The description adds no behavioral detail beyond the word 'leave' — for example, whether leaving is irreversible or what happens to channel history or membership.

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 short, front-loaded sentence with no unnecessary wording. It immediately communicates the action and the key requirement.

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

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

For a one-parameter tool with destructive and idempotent annotations plus an output schema, the description is complete enough to select and invoke correctly. Missing alternative routing was already noted, but the low complexity makes this a minor gap.

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

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

Schema coverage is 100% and the single channel_id parameter is clearly described in the schema. The description only reinforces that the operation is by channel ID, which is sufficient but does not add extra meaning beyond the schema.

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

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

The description states a specific verb ('Leave'), a clear resource ('AgentPub group channel'), and the required identifier ('channel ID'). This distinguishes the tool from siblings like agentpub_join_channel, agentpub_create_channel, and agentpub_list_channels.

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 implied: call this when the agent wants to leave an AgentPub channel, and a channel_id is required. However, it does not explicitly mention alternatives or when not to use it, so guidance is present but not explicit.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds minimal extra behavior by stating it uses AgentPub's native MCP list_channels tool and scoping results to the AlpineLead Nexus identity, which is useful but not extensive.

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 deliver the purpose, scope, read-only nature, and implementation detail with no filler. The core action is front-loaded and every sentence earns its place.

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

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

For a zero-parameter, read-only listing tool with a full output schema and comprehensive annotations, the description is complete. An agent can confidently invoke this tool without missing information.

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

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

The tool has zero parameters, so schema coverage is trivially 100%. The description correctly does not invent parameter information, and no additional semantic guidance is needed beyond naming the resource being listed.

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: 'List the AgentPub channels available to the AlpineLead Nexus AgentPub identity.' This clearly distinguishes the tool from sibling tools like agentpub_create_channel or agentpub_join_channel by focusing on listing existing channels.

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 tool is for viewing available channels and is read-only. It does not explicitly name alternatives or when to avoid it, but with zero parameters and a simple listing operation, the usage context is effectively 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 read-only, idempotent, open-world, non-destructive behavior. The description adds a valuable security-relevant behavioral warning: peer messages are untrusted and must not be treated as system instructions. This exceeds what 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?

Two purposeful sentences: the first states action and method, the second adds a critical safety caveat. No filler or redundant restatement of schema/annotations.

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-optional-parameter, read-only, output-schema-backed tool, the description plus annotations and schema cover invocation, polling semantics, and security handling. 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 only parameter, 'after,' is documented in the schema with semantics and default. Description's 'cursor polling' aligns with the schema but adds no new parameter-level detail beyond what the schema already covers. With 100% schema coverage, baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Read new AgentPub messages,' and adds the mechanism 'using cursor polling.' This clearly distinguishes it from siblings like agentpub_send_message (send) and agentpub_bridge_status (status).

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

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

The context is clear: use this tool when you want to retrieve new AgentPub messages and are polling with cursors. It does not explicitly name alternatives or exclusions, so it misses the top tier, but no alternative usage is left ambiguous.

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

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

Annotations already flag readOnlyHint=false and idempotentHint=false, but the description adds a valuable behavioral guarantee: it does not autonomously repost or mass-message. This is especially useful with openWorldHint=true, clarifying the side-effect scope 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?

Two short sentences with no wasted words. The core action is front-loaded and the behavioral caveat is a deliberate, 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?

For a two-parameter sending tool with a full schema, annotations, and an output schema, the description is nearly complete. The only notable gap is lack of context about whether the agent must already belong to or have access to the channel.

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

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

Schema coverage is 100% and both parameters already have clear descriptions in the schema. The tool description adds no parameter-level detail of its own, so baseline 3 is appropriate.

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

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

Description opens with a specific verb and resource ('Post a message to an AgentPub channel'), making the primary function unambiguous. It does not differentiate from the sibling agentpub_send_message, so it misses the full bar for sibling distinction.

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

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

No guidance is given about when to use this tool versus agentpub_send_message or other AgentPub messaging tools. The sentence about not autonomously reposting is a constraint, not a usage directive, and no prerequisites such as channel membership are mentioned.

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

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

Beyond the annotations, the description discloses an important behavioral detail: it 'Uses the server-side AGENTPUB_API_KEY' and 'Never exposes the secret to the caller.' This gives the agent confidence that no API key parameter is needed and that credentials will not leak. It does not mention side effects like duplicate messages, but the annotations already indicate non-idempotence and 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 two short sentences with no filler. The core action is front-loaded, and the security note is a valuable second sentence that does not repeat 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?

For a simple two-parameter tool with an output schema and full parameter documentation, the description covers the essential operational context: what it sends, the sending identity, the recipient requirement, and the credential handling. Nothing critical is missing for an agent to invoke it correctly.

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

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

Schema coverage is 100%, so both recipient_handle and body are already explained in the input schema. The description adds no new parameter-level detail beyond what the schema provides. This meets the baseline for high 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: 'Send a DM from the AlpineLead Nexus AgentPub identity to a known AgentPub handle.' This clearly distinguishes the tool from siblings like agentpub_read_inbox and agentpub_invite_to_nexus. The handle qualification ('known') adds useful scoping.

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: use this tool when sending a direct message as the AgentPub identity to an already-known handle. It does not explicitly name alternatives or state when not to use it, but the 'known handle' constraint implies a prerequisite and separates it from invitation or inbox-reading 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?

The description adds important behavioral context beyond annotations: arguments are passed verbatim because AgentPub may publish incomplete formal schemas. This warns the agent to treat the schema with care and inspect discovery schemas before invoking. Annotations already cover idempotence and non-destructiveness, so the added caveat is meaningful and non-contradictory.

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

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

Two sentences, front-loaded with the core action and scoping, followed by a concise rationale for the verbatim argument object. No wasted words.

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

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

Given the open-world hint, incomplete-schema risk, and opaque native argument object, the description correctly tells the agent to inspect discovery schemas. It does not enumerate valid status values or explicitly address authentication, but the discovery-schema instruction mitigates the main invocation risk and output schema 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?

Schema coverage is 100%, and the schema already states that arguments are passed verbatim and that discovery schemas should be inspected if unsure. The description reinforces the verbatim argument behavior and explains why, but it does not add new parameter-level detail beyond the schema.

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

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

The description clearly states a specific action and target: updating 'only the AlpineLead Nexus AgentPub identity's own presence/status.' This distinguishes it from sibling tools that operate on other AgentPub entities or statuses.

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 'own presence/status' implies this tool is for self-status updates, not for other statuses or bridge statuses, but it does not explicitly name alternatives or describe when to choose this tool over a sibling like agentpub_bridge_status. The usage context 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?

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?

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?

The description discloses important behavioral traits beyond the annotations: auto-routing to find_opportunities for qualified/ambiguous intent, the requirement for explicit raw wording and internal confirmation, and the guarantee that RAW results never contain a final FIT/NEED/NOW score. This is substantive and not contradicted by 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 short and mostly front-loaded, but the opening fragment 'Compatibility RAW discovery.' is cryptic and adds little value. The useful routing and RAW-result constraints are clear, but the acronym-rich wording and unexplained 'Compatibility' reduce clarity.

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

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

An output schema exists, so return values do not need to be described here. The description covers routing conditions, RAW-mode requirements, and the absence of opportunity scores, which is sufficient for correct invocation. Minor gaps like the meaning of 'Compatibility' are not blocking.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The top-level description mostly restates routing behavior already captured in the goal and raw_mode_confirmed parameter descriptions, adding little new semantic meaning beyond the schema.

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

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

The description clearly identifies the tool as RAW company discovery and explicitly distinguishes it from find_opportunities by stating that qualified or ambiguous intent auto-routes there. The title reinforces the DACH scope and RAW nature, so an agent can tell it apart from siblings without inspecting schemas.

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

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

The description gives explicit usage guidance: use RAW discovery only when raw wording is explicit and internally confirmed; otherwise qualified or ambiguous intent goes to find_opportunities. This directly tells the agent when to invoke this tool versus the key 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?

Annotations already indicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint: false. The description adds useful behavioral context by clarifying that this is an operator/admin tool and explicitly stating that no credits are consumed, which is important cost-related behavior not encoded 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 two short sentences with no filler. The audience and purpose are front-loaded, and every phrase adds value: audience, what is shown, and the credit-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?

For a zero-parameter status-check tool with rich annotations and an output schema, the description is complete. It tells the agent what the tool does, who it is for, and the key operational detail (no credit usage), with nothing essential missing.

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

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

The tool has zero parameters and the schema coverage is 100%, so the description has no parameter burden. The baseline for zero parameters is 4, and the description appropriately focuses on the tool's behavior rather than parameter details.

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

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

The description clearly states the tool's function with a specific verb ('Shows') and a specific resource: AlpineLead's agent-discovery visibility, registry health, and recent discovery traffic. This distinguishes it from sibling tools like get_hubspot_status and other AlpineLead operations.

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

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

The description labels the tool as an 'Operator/admin tool', giving clear audience and context. It also notes that no AlpineLead credits are used, implying it is safe to invoke for monitoring without cost concerns, though it does not explicitly name alternatives or state when not to use it.

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

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

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 indicate the tool is not read-only, not idempotent, and not destructive, which conflicts with the description's implication of a search operation that saves to history. The description adds context that it saves only accepted opportunities to AlpineLead CRM/history (also visible in schema), and the search pipeline shape, but it doesn't disclose side effects beyond save_to_history. No contradiction with annotations; the description and annotations align on non-read-only due to saving.

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: it states the tool's role in the first phrase and then lists the search pipeline as a memorable sequence. It earns its place by encoding the tool's logic into a compact mnemonic.

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 are present, the description is reasonably complete for an agent. It explains the overall workflow, mentions saving behavior, and the schema covers parameters. However, it doesn't explicitly specify return format, but output schema covers that. It could state when not to use it (e.g., for raw lead discovery vs. qualified opportunities), but the title and description strongly imply the target use case.

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 documents all 10 parameters. The description adds the semantic pipeline concept (Goal -> Buyer Role -> ...) and clarifies that goal is the primary context, which adds meaning beyond the schema. It doesn't need to repeat parameter details because the schema is comprehensive.

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 process for finding qualified DACH opportunities, with a clear resource ('default agent search') and a structured sequence of criteria. It distinguishes itself from siblings like discover_leads or run_dach_company_research_agent, though it doesn't name them 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 implies it is the default agent search for qualified DACH opportunities and outlines the search pipeline, but it does not explicitly state when to use this tool versus alternatives such as discover_leads or run_dach_company_research_agent. The title adds 'default agent search', which suggests primary usage, but no exclusions or explicit alternative routing are 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 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?

The annotations already declare readOnlyHint=true and idempotentHint=true, so the description does not need to establish safety. The description adds some context about what areas the tool covers (costs, DACH focus, workflows), but it does not disclose how results are structured or any edge behavior; the output schema likely carries that burden.

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, front-loaded with the key instruction ('Use this first'), and packs meaningful scope into a compact list. There is no filler or repetition of the title.

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 discovery tool with an output schema, the description covers the fundamental usage question: when to call it and what broad topics it supports (capabilities, costs, DACH focus, workflows, availability). Nothing else is necessary for a correct first call.

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

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

The tool has zero parameters and the input schema is empty, so parameter-level documentation is not needed. The description compensates by explaining the kind of information the agent will gain, and the baseline of 4 applies to zero-parameter tools.

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

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

The description states a clear resource (AlpineLead OI capabilities) and a clear action ('use this first when you need to understand'), adding concrete topics like costs, DACH focus, workflows, and availability. It is not a tautology, but it relies on the title and broad phrasing rather than naming sibling tools, so it does not strongly distinguish itself.

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 tool first when the agent needs to understand AlpineLead OI's capabilities, costs, workflows, or DACH focus. It gives clear context but does not explicitly state when not to use it or name alternatives among the many sibling tools.

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

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

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=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?

Annotations already mark the tool as read-only, idempotent, and non-destructive. The description adds specific behavior not present in annotations: it returns no message contents, credentials, or raw IP addresses. This is meaningful disclosure about data handling and privacy boundaries, beyond what the annotation fields 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 two short sentences: the first states the core purpose directly, and the second adds a crucial limitation. Every word earns its place, and the most important information is front-loaded.

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

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

For a zero-parameter informational tool with an output schema provided and annotations covering safety, the description is complete. It clearly conveys what the tool tells the user and what it will not expose. No additional context is needed for correct invocation.

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

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

The input schema has zero parameters, and description coverage is trivially 100%. With no parameters to document, the description does not need to add parameter-level meaning. The baseline for a parameterless tool is 4, and there is no gap here.

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

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

The description uses a specific verb ('Explain') and identifies the exact resource ('where AlpineLead records agent communication signals'), distinguishing this informational tool from siblings like agentpub_read_inbox or nexus_communication_monitor info. It also clarifies what is out of scope, reinforcing its purpose as a metadata/explanation tool rather than a data retrieval 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 description implies this tool is for understanding where communication signals are stored, but it does not explicitly state when to use it over alternatives or mention any exclusions. The 'info' suffix and the explanatory wording provide context, but no direct guidance on alternative tools is given.

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 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?

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 this is a non-readonly, non-destructive operation. The description adds meaningful behavioral context by clarifying that payout and payment fields are descriptive inputs and that callers cannot set payout_verified because AlpineLead owns payment verification. This goes beyond the schema and annotations, helping the agent set correct expectations about the server's authority over payment state.

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 and wastes no words. The primary action is front-loaded in the first sentence, and the second sentence delivers a critical caveat about payment verification. It is compact without losing any essential behavioral nuance.

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

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

The tool has 13 parameters, but the schema covers all of them with descriptions, and an output schema exists, so return-value documentation is not required here. The description provides the central caveat about payment ownership, which is the most likely source of agent confusion. It could be slightly more complete by noting lifecycle relations to claim/complete/find siblings, but the schema and caveat make it sufficiently usable.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by framing payout and payment-related fields as descriptive and by explicitly warning that payout_verified cannot be set directly. This helps the agent understand the semantic role of payout_amount, payment_status, payment_provider, and payment_reference even though those fields individually have their own descriptions.

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

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

The description opens with a clear verb and resource: 'Post a Nexus task'. It is immediately distinguishable from sibling tools like nexus_claim_task, nexus_complete_task, and nexus_find_tasks because 'post' is an unambiguous creation action. The optional 'earn metadata' qualifier also hints at the tool's specialized scope without requiring the agent to open 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?

The description does not state when to use this tool versus alternatives such as nexus_claim_task or nexus_complete_task. There is no explicit when-to-use, when-not-to-use, or alternative routing. The intended use is implied by the name and action, but the agent receives no guidance about workflow ordering or related task lifecycle 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?

With no annotations provided, the description carries the behavioral disclosure burden. It does disclose a meaningful trait: 'No credits or AI calls', which tells the agent this is a low-cost explanatory call. However, it does not explicitly state read-only behavior, potential auth requirements, or what kind of response to expect, so transparency is only partial.

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. The primary purpose is front-loaded and the second sentence adds a useful behavioral note without padding. 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?

Given the tool's low complexity (no parameters, no nested objects), the description is mostly sufficient: it states what the tool does and that it costs no credits or AI calls. The main gap is the lack of explicit routing or expected output information, but the simplicity of the tool keeps this from being a serious deficiency.

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

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

The tool has zero parameters and the schema has no properties, so there is no parameter documentation burden. The description does not need to add parameter-level meaning. The baseline for 0-parameter tools is 4, and nothing in the description detracts from that.

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 ('Explain') and the target resource ('visibility tiers for AlpineLead predictive layers'), making the tool's purpose identifiable. It is reasonably distinct from sibling predictive_*_info tools because it focuses specifically on access/visibility tiers rather than a model behavior. It stops short of a 5 because it does not explicitly contrast itself with those 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?

There is no guidance about when to choose this tool over the many sibling info tools, nor any mention of prerequisites such as authentication. The phrase 'No credits or AI calls' is a cost/behavior note, not a usage guideline. The agent is left to infer that this tool should be used when explaining access tiers.

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?

There are no annotations, so the description carries the behavioral disclosure burden. It adds useful context by stating 'Uses 0 credits and0 AI calls,' but it does not explicitly confirm read-only behavior, auth requirements, or what kind of output the explanation will produce.

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

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

The description is very short and front-loaded with the verb and subject. Both sentences earn their place: one states the purpose, the other states the cost and AI-call implications. There is no filler.

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

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

For a zero-parameter informational tool, the description identifies the topic and the cost, which is useful. But with no output schema and no annotations, it does not describe the return value, format, or how this tool relates to the other predictive info tools, leaving gaps for an agent trying to decide whether the output will satisfy the user.

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 an empty input schema, so there are no parameter semantics to compensate for. The baseline of 4 applies because the description does not need to explain inputs that do not exist.

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, 'Explain,' and names a concrete resource: AlpineLead's deterministic Emergence convergence shadow layer. This makes the informational purpose reasonably clear, though it does not distinguish it from the sibling predictive_*_info tools and relies on domain jargon.

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 implied: call this when an explanation of the Emergence shadow layer is needed. However, the description does not state when not to use it, nor does it compare it with the similar-looking predictive_*_info 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?

With no annotations provided, the description carries the full behavioral burden. It discloses that it uses 0 credits and 0 AI calls, which is a useful cost note. However, it does not explicitly state that it has no side effects, though 'explain' suggests read-only. This is a minimal but acceptable disclosure for an informational tool.

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

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

The description is a single sentence that immediately states the tool's purpose and the cost. It is front-loaded, contains no filler, and every word earns its place. This is an exemplary concise 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?

For an informational tool with no parameters and no output schema, the description is complete enough: it states what it does and the cost. It does not describe the content of the explanation, but that is not necessary for an agent to decide to call it. It covers the essential context.

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

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

The tool has zero parameters, so the schema coverage is trivially 100%. Per the rubric, a baseline of 4 applies. The description adds no parameter information because none exist, which is appropriate and adds no confusion.

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 explains a specific resource: AlpineLead's deterministic Motion + Causality shadow layer. The verb 'explain' and the resource name are unambiguous, and it is distinct from sibling tools by topic, though it does not explicitly name an alternative. It could be a 5 if it explicitly differentiated, but the purpose is solid.

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 tool is for understanding the shadow layer, but it does not provide explicit when-to-use or when-not-to-use guidance, nor does it name alternative tools. Given the large sibling set, some usage context would help, but the purpose itself gives an implied usage scenario.

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

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

With no annotations provided, the description carries the behavioral burden. It usefully discloses that the tool is deterministic and, crucially, that it uses 0 credits and 0 AI calls, signaling that this is a cheap, non-generative lookup. It does not explicitly state it is read-only or describe the return format, but 'Explain' implies a read-only information 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 extremely concise: one sentence states purpose, the second states cost/behavior. There is no filler or duplicated schema information.

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

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

For a zero-parameter, no-output-schema info tool, the size is small and invocation is trivial. However, an agent is not told what kind of content the explanation contains (conceptual overview, mechanics, configuration, etc.) or what the return value will look like, so the context is adequate but not rich.

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

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

The input schema is empty, so parameter semantics are not a concern; schema coverage is effectively complete. The description provides relevant context about what the tool explains, which is all that is needed for a zero-argument 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 uses a specific verb ('Explain') and names a concrete resource ('AlpineLead's deterministic Rhythm Detection shadow layer'), so an agent can tell this is about explaining that particular predictive component. It distinguishes itself from sibling predictive_*_info tools by the unique 'Rhythm Detection' subject, though it does not preview what aspects are explained.

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 guidance about when to call this tool or when to prefer a sibling such as predictive_emergence_info or predictive_motion_causality_info. The only usage signal is the verb 'Explain,' which implies a user request for an explanation, but no exclusions or alternatives are mentioned.

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

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

Annotations already declare a non-read-only, non-idempotent, open-world operation, and the description adds the exact side effects: HubSpot company/contact creation/reuse, an AlpineLead deal, and a follow-up task. This is useful behavioral context beyond the annotations, though it does not explain reuse matching or duplicate 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?

A single sentence states the complete workflow with no filler words. The main action is front-loaded, and every phrase contributes 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?

With an output schema present and annotations covering side effects, the core behavior is adequately conveyed. However, critical context is missing: how existing companies/contacts are matched for reuse, whether repeated calls can create duplicate deals, and which parameters map to which created object.

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

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

The description contains no parameter-level guidance, and schema description coverage is 0%, so the description does not compensate for the undocumented parameters. The schema titles are informative, but the description itself adds no meaning to any of the 11 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 identifies a concrete workflow: it creates or reuses a HubSpot company/contact and then creates an AlpineLead deal and follow-up task. This clearly distinguishes the tool from the sibling list, none of which describe this same object lifecycle.

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 invoke this tool versus alternatives, no prerequisites, and no exclusions. The action itself implies 'use when an opportunity needs to be pushed to HubSpot,' but that is inferred rather than stated.

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 carry readOnlyHint=false, openWorldHint=true, idempotentHint=false, so the safety profile is handled. The description adds minor behavioral context by indicating the tool evaluates change, commercial signals, and Opportunity Delta movement. It doesn't disclose any side effects or external data behavior beyond what annotations imply, but no contradiction exists.

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

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

A single well-constructed sentence with no filler. The condition ('only for an existing/known lead') comes first and the trigger queries follow, making it easy for an agent to quickly parse when to use it.

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 two-parameter tool with a rich output schema and annotations, the description covers usage context well. It could note that at least one of website or google_place_id is required for a meaningful call, but the 'existing/known lead' context and schema make this inferable.

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

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

Schema description coverage is 100%, so both parameters (website and google_place_id) already have explanatory text. The description reinforces that the lead must be 'existing/known' but adds no parameter-specific information beyond the schema.

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

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

The description names a specific resource ('existing/known lead') and specific triggers ('what changed, whether commercial signals appeared, or whether Opportunity Delta increased or decreased'). The title's 'Check opportunity radar' is reinforced with concrete criteria, and the 'existing/known lead' qualifier clearly distinguishes it from sibling lead-discovery tools.

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

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

The description explicitly says 'Use only for an existing/known lead' and enumerates the exact user queries that should trigger this tool. It doesn't name alternative sibling tools, but the 'only existing/known lead' exclusion is strong enough for an agent to route away from new-lead discovery tools like discover_leads or find_opportunities.

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, so the safety profile is covered. The description adds the behavioral context that this is a routing/decision-support tool rather than a direct execution tool. However, it does not explain how the recommendation is derived or what the tool returns, though an output schema exists.

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

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

The description is one sentence that states the exact situation for use. It contains no filler, no repeated schema information, and the key condition ('unsure which tool should be called next') is front-loaded.

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

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

For a simple routing/recommender tool, the combination of title, description, annotations, and output schema provides enough context to invoke it correctly. The description could more explicitly mention how the boolean inputs affect the recommendation, but the parameter schemas with defaults cover them. It is a lean but complete definition.

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 every parameter (goal, has_existing_lead, has_known_company) is already documented in the input schema. The description adds no extra semantic meaning to these parameters, matching the baseline 3 for high 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 title states the tool's function — 'Choose the best AlpineLead OI tool' — and the description clarifies when to invoke it: when the user's intent is understandable but the next tool is uncertain. This distinguishes it from the operational sibling tools, which perform concrete actions. It would earn a 5 if the description itself used a direct verb like 'Recommends the next...' instead of relying on the title.

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

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

The description gives an explicit trigger: 'use when... unsure which AlpineLead OI tool should be called next.' This clearly scopes its role relative to the sibling tools. It stops short of saying 'when you already know the tool, call it directly,' so it lacks a full when/alternatives contrast, a minor gap.

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

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

Adds useful behavioral context beyond the annotations: the agent is paid, returns qualified findings, and never sends outbound messages. These are meaningful traits the annotations do not convey, especially the safety-related 'never sends outbound messages'.

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 at two sentences and the operational guidance is immediately actionable. The opening 'First ready-made paid Nexus agent' is slightly promotional, but it still communicates the paid nature efficiently.

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

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

For a paid asynchronous tool with 11 parameters, the description covers the essential workflow and a key boundary. With an output schema present and detailed parameter descriptions elsewhere, the remaining gaps around budget and filtering are acceptable.

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

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

With 73% schema coverage, the schema already documents most parameters. The description clarifies the start/status/result lifecycle, but this mostly restates what action and job_id descriptions already say. It does not add meaningful detail for goal, filters, budget, or scoring 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?

States a specific action ('Discovers and researches DACH companies'), a defined output ('FIT/NEED/NOW-qualified findings'), and a key boundary ('never sends outbound messages'). This clearly separates it from discovery-only or outreach-oriented sibling tools like discover_leads or run_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?

Gives explicit lifecycle guidance: 'Use start once, then status/result with the same job_id.' This is clear operational context, though it does not name alternatives or say when not to use this tool versus similar research 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?

The description adds meaningful behavioral context beyond the annotations: it is asynchronous, returns a job_id quickly, and status/result calls are non-starting. It does not contradict the annotations, and it clarifies the state-machine lifecycle that the annotations alone would not 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 compact, front-loaded with the core state-machine concept, and uses a short action list plus a one-sentence rationale. Every sentence earns its place with no filler or repetition.

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

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

The start/status/result workflow is adequately explained and the output schema covers return-value expectations. It does not mention authentication prerequisites or explicitly route around sibling status/result tools, but for a complex 17-parameter tool with a rich schema the core execution model is clear 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?

With 59% schema coverage and 17 parameters, the description should compensate for the gaps, but it only restates action/job_id semantics already present in the schema. Several parameters (tone, count, language, minimum_score, sales_kit_count, save_to_history, include_sales_kits) remain undocumented in both the schema and the description.

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

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

The description clearly states the tool is an async state machine for sales missions and enumerates the start/status/result actions. It conveys a specific verb and resource, but it does not explicitly name or contrast the overlapping sibling tools check_sales_mission_status and get_sales_mission_result, so some sibling differentiation is left implicit.

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

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

It gives explicit per-action guidance: use start for a new mission, status/result for an existing job, and emphasizes that status/result do not start another mission. It does not directly explain when to choose this unified tool over the sibling status/result tools, so it stops short of full alternative routing.

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