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

The description adds substantial behavioral detail beyond the annotations: it sends nothing, reads structured thread data, matches by stable member_id, and guarantees a reply cannot cause a duplicate first touch. This meaningfully clarifies side effects and idempotency beyond the idempotentHint annotation.

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

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

The description is front-loaded with the core purpose and the safety-critical 'Sends nothing' statement. Each subsequent sentence adds a distinct behavioral guarantee or scope restriction, and no sentence feels redundant 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?

The description covers the tool's purpose, matching logic, scope restrictions, side effects, and idempotency behavior. An output schema exists for return values, so the remaining details are sufficiently complete for an agent to invoke this tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents both 'scrolls' and 'campaign' adequately. The description adds no parameter-specific meaning, so the baseline score of 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Read the Sales Navigator inbox and mark leads who replied.' It also clarifies the exact matching mechanism and scope, which distinguishes this from generic messaging tools. The intent is unmistakable and would let an agent select it correctly.

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

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

The description gives clear context: only leads this server recorded a send for are considered, and conversations messaged by hand elsewhere are ignored. This helps an agent know when not to invoke the tool, though it does not explicitly 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?

Annotations already indicate readOnlyHint and openWorldHint. The description adds useful behavioral context beyond annotations: it may launch or reuse a browser, verifies landing on a signed-in /sales page, and returns the profile directory and headless setting. 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?

Description is compact and front-loaded. The core purpose appears in the first sentence, usage guidance in the second, and a clear 'Returns:' block for the result structure. 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 tool with an output schema, this description covers purpose, usage timing, behavioral side effects, and return summary. Nothing essential is missing for an agent to decide when to call and interpret the result.

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 empty schema properties, so the semantic baseline is high. The description does not need to explain parameters; its return-value summary compensates for the lack of param-related guidance.

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

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

States a specific verb and resource: checking whether the browser profile has a live Sales Navigator session. The description distinguishes this from siblings like outreach_status and pipeline_status by focusing on session/sign-in state rather than campaign or outreach 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?

Explicitly says 'Use this first when searches fail' and mentions the decision outcome: whether to run `--login` again. This gives clear when-to-use guidance and implicitly differentiates it from search-oriented 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?

Even with readOnlyHint and openWorldHint annotations, the description adds substantial behavioral context: one LinkedIn request per lead with ~1s pacing, results stored in the lead_enrichment table keyed by member_id, search records never modified, enriched leads reused across searches, and resumable/idempotent behavior with failed fetches retried. This goes well beyond the annotations and is accurate to the operational reality.

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 information-dense but each sentence earns its place: the core purpose is front-loaded, followed by the technical constraint, cost model, storage behavior, and idempotency semantics. It avoids fluff and repetition while covering all needed operational 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?

Given the tool's complexity, the description is complete: it explains why the tool exists, what it costs, where results go, how they are joined in, how idempotency works, and how to sample safely. The output schema exists, so return-value details are not the description's job. An agent has enough to select and invoke this tool correctly without further investigation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by explaining the cost implications of limit, clarifying that only_missing=true skips already-fetched leads and that failures remain pending for retry, and reinforcing how url_or_hash identifies the query. These details enrich parameter meaning beyond the schema's 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 specific verb and resource: 'Add Open Profile / InMail status to a saved contact search.' It clearly distinguishes itself from closely related siblings like search_contacts and fetch_lead_profiles by explaining that this tool enriches saved query results with a field only available from profile requests.

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: it is a separate opt-in tool rather than part of search_contacts, there is no bulk endpoint, users should start with a limit to sample before committing, and only_missing=true lets repeated calls walk through the query. This tells an agent exactly when and how to invoke it versus 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?

The annotations declare readOnlyHint=true, but the description says the tool writes files to an output folder, which is a side-effecting behavior and contradicts the read-only claim. The description also does not disclose overwrite behavior, file naming conventions, or whether the export preserves prior files.

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 filler. It efficiently conveys the core action, resource, and destination in twelve words and earns its place 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?

The schema covers all parameter semantics and an output schema is present, so return-value documentation is not required. However, the description lacks explicit usage guidance and contains a behavioral contradiction with the readOnlyHint annotation, leaving the definition only partially complete for an agent deciding whether and how to invoke 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 the schema already documents all parameters meaningfully. The description adds little beyond the schema, but the baseline of 3 applies because no compensation is needed.

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

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

The description uses a specific verb ('Export') with a clear resource ('a saved query's records') and destination ('files under the output folder'). This clearly distinguishes it from result-returning siblings like get_results, since the focus is on producing files rather than returning data in-memory.

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 'saved query's records' implies the prerequisite of having a saved query, and the schema parameter description reinforces that url_or_hash comes from list_queries. However, the description does not explicitly state when to use this tool over alternatives such as get_results, nor does it give any when-not-to-use guidance. Usage context is implied rather than clearly 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 declare readOnlyHint=true and openWorldHint=true, and the description adds meaningful behavioral context: one heavy request per lead, ~15 KB per lead vs ~240 bytes for enrichment, the need for ENABLE_PROFILE=true, and resumability where successfully fetched leads are skipped. 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?

The description is front-loaded with the core purpose, then uses concise paragraphs to explain the distinction from enrich_leads, the cost/configuration caveat, and resumability. Every sentence contributes either to routing the agent correctly or to understanding operational behavior.

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

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

Covers the essential operational facets: heavy cost, configuration requirement, resumability, endpoint relationship, and payload size. With an output schema present and annotations for safety, nothing material is missing for an agent to select and invoke this tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents both parameters well. The description adds some context around limit being per-call and url_or_hash identifying the query, but this is largely implicit in the schema. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('Fetch full profiles for a query's leads'), and explicitly distinguishes itself from the sibling enrich_leads by describing the wider projection and heavier payload. The purpose is immediately clear and not confusable with any 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?

Explicitly explains when to use this tool: only for leads you are about to write to, whereas enrich_leads runs across a whole list to find who is free to message. It also notes the ENABLE_PROFILE=true requirement and resumable behavior, giving clear operational usage guidance.

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

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

Annotations already declare readOnlyHint=true, and the description adds useful context by specifying that the tool reads from the local store only and makes no external call to LinkedIn. This goes beyond the annotation and sets accurate expectations about side effects and data freshness.

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

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

The description is two sentences, front-loads the core purpose, and every sentence earns its place: the first defines the tool, the second explains its scope and prerequisite. There is no redundant or vague wording.

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 a single required parameter, full schema description coverage, an output schema, and readOnlyHint annotation, the description covers the remaining needed context: local-only reads and the dependency on fetch_lead_profiles. An agent has everything needed to select and invoke the tool correctly.

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

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

The input schema already fully documents member_id as 'Stable LinkedIn member id' with 100% coverage. The description does not add additional parameter-level meaning, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb and resource ('Read one stored full profile') and clarifies the tool's purpose as the source for drafting messages. It also distinguishes itself from fetch_lead_profiles by noting it reads from the local store only and does not call LinkedIn.

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

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

The description explicitly states when to use this tool and gives a prerequisite: run fetch_lead_profiles first for leads that have not been fetched. It also clarifies a key limitation ('does not call LinkedIn'), so an agent knows this tool is not for live enrichment.

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 the description adds meaningful behavioral context: it is intentionally bounded and is not meant for large retrieval. It also clarifies the purpose of the data pull (analysis), which helps the agent set expectations.

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

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

Two tight sentences with no filler. The primary purpose is front-loaded, and the design rationale plus routing to the sibling tool is delivered in the second sentence.

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

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

For a read-only, bounded sample tool, the description covers purpose, scope, and the large-set alternative. The schema covers parameters and the output schema covers return shape, so nothing needed to call it correctly is missing.

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

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

Schema description coverage is 100%, and the schema already fully documents url_or_hash, limit, and offset with ranges and defaults. The description's mention of 'bounded' aligns with the schema but adds no new parameter-level meaning beyond it.

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

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

States a specific action ('Pull a bounded slice'), a specific resource ('a saved query's records'), and a clear intent ('into the conversation for analysis'). The phrase 'bounded slice' distinguishes it from the sibling export_results, which is designed for large sets.

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

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

Explicitly says when to use this tool: for bounded in-context analysis. It also names the alternative for large sets ('prefer export_results') and explains why, preventing the agent from overloading context.

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

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

The readOnlyHint annotation already indicates a safe read operation. The description adds useful behavioral detail: it returns a Dict with per-query fields including status, last_page, total_available, and records_count. It also reveals the status enum values and how to use the returned url_hash. This goes beyond the annotation and gives the agent a clear model of the tool's output and its role in the workflow.

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: the first sentence states the core purpose, and the following section succinctly lists the return structure and provides an action pointer. Every sentence adds value, with no redundant 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?

Given that the tool has no parameters, is read-only, and has an output schema, the description covers all essential information: what the tool returns, the exact fields, status values, and how to use the output with sibling tools. Nothing an agent needs to invoke this tool successfully is missing.

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

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

The tool has zero parameters, and the schema is empty, so there are no parameter semantics to document. The description appropriately mentions url_hash only as part of the output, not as an input. Baseline for 0 params is 4, and the description reinforces the data shape without needing to clarify any 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 begins with a specific verb and resource: 'List every saved search and its progress.' This clearly states what the tool does and its scope ('every'), distinguishing it from sibling search tools like search_contacts or search_accounts. The addition of 'progress' adds a unique, purpose-defining detail not present in 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 includes a practical usage pointer: 'Use a url_hash with export_results or get_results.' This tells the agent how the output of this tool feeds into other tools. It does not explicitly state when to prefer list_queries over alternatives, but the tool's self-explanatory nature and the explicit downstream routing partially compensate.

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 readOnlyHint annotation, it discloses global dedupe by stable member_id, per-campaign status tracking, exclusion of already-messaged leads, and the free-vs-InMail-credit distinction. This is substantial behavioral context an agent needs before calling.

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 paragraphs, all information-dense with the main purpose front-loaded. The only slight redundancy is repeating the 'free to message' idea in the last paragraph, but nothing is wasted.

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 declare read-only, the description covers all essential call-time knowledge: eligibility, dedupe, campaign scoping, prerequisite enrichment, and the paid-lead toggle. No critical selection 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?

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds useful context around open_profile_only and campaign/dedupe semantics, but it does not add meaning to limit or url_or_hash beyond what the schema provides.

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

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

The first sentence, 'Leads eligible for a first message, best channel first,' crisply identifies the resource and selection intent. 'Read-only' plus the dedupe explanation clearly separates it from execution-style tools like run_outreach_batch and send_message.

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 prerequisite ('Run enrich_leads first or this returns nothing') and explains the open_profile_only default/alternative behavior. It does not explicitly name sibling tools to use instead for sending or follow-up, but the intended 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?

The annotation readOnlyHint=true already establishes that this is a safe read operation, and the description does not contradict it. The description adds the context that the tool returns aggregate counts and a remaining daily-cap value, but it does not disclose scoping details such as time window, status definitions, or cap behavior. This is adequate given annotation coverage but not rich.

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 core action and key outputs. There is no filler or repeated information from the title or schema, and the brevity is appropriate for a simple read-only aggregation 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 one-parameter, read-only tool with an output schema, the description plus schema is sufficient to invoke the tool correctly: the agent knows what it returns, that it can be filtered by campaign, and that it is non-mutating. It does not explain the exact meaning of 'daily cap' or the time window, but those details are likely covered by the output schema and are not necessary for making the 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 input schema covers the only parameter 100%, including an explicit description: 'Restrict to one campaign. Omit for all.' The tool description itself adds no parameter-level meaning beyond what the schema already provides, so it 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 ('Counts') and a clear resource/scope ('by status and channel'), plus an additional distinct metric ('remaining daily cap'). It is clearly not a mutation or search tool and reads as an aggregate reporting tool, though it does not explicitly differentiate itself from sibling status tools like pipeline_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 description gives no guidance on when to prefer this tool over alternatives such as pipeline_status, check_session_status, or next_outreach_batch. It does not state a use case like 'check outreach capacity before sending' and provides no exclusions or 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 annotation already signals readOnlyHint=true. The description adds meaningful behavioral context by revealing that the underlying state lives across four tables and this tool joins them into one funnel view, which is not inferable from annotations alone. No contradiction.

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, no fluff: the first states the core deliverable with a concrete stage list, the second explains why the tool exists. Each sentence carries distinct informational value.

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

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

With one required parameter fully documented, readOnlyHint provided, and an output schema present, the description supplies the remaining needed context: the funnel stages and the consolidation behavior. No critical information for calling the tool correctly appears missing.

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

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

Schema description coverage is 100%, and the single parameter url_or_hash is already explained as the query's url_hash or original search URL. The tool description adds no additional parameter-level meaning, so baseline 3 is appropriate.

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

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

The description clearly defines the tool as a single consolidated pipeline/funnel view for a query, with explicit stages: scraped → enriched → open → profiled → sent. It communicates the resource and scope well, though it does not explicitly differentiate from named sibling tools.

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

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

The description establishes a clear use case: answer 'where is everything?' for one query without checking multiple tables. It conveys when the tool should be used but does not explicitly state when not to use it or name an alternative.

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

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

The description goes well beyond the annotations by explaining that the tool opens conversations, searches for message text, resolves rows to `sent` or `failed`, and explicitly says 'Sends nothing.' It also discloses the effect on duplicate prevention. This adds substantial context beyond idempotentHint and readOnlyHint.

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

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

The description is front-loaded with the core purpose, then gives essential background, then clarifies safety and semantics. Every sentence adds value; there is 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?

Given the output schema exists and the two parameters are fully documented, the description covers all necessary behavioral context: the state transition, the ambiguity scenario, the no-send guarantee, and the duplicate-protection implication. Nothing critical is missing.

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

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

Schema description coverage is 100%, so both `limit` and `campaign` are already fully documented. The tool description provides useful background but no additional parameter-level semantics. This matches the baseline for fully covered schemas.

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 first sentence uses a specific verb and resource: 'Settle sends stuck in `sending` by checking LinkedIn itself.' It clearly identifies the outcome: resolving rows to `sent` or `failed`. This distinguishes it from sending tools like send_message and status tools like outreach_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 description gives a clear trigger scenario: a `sending` row means the Send click happened but the outcome was never recorded. It also explains the follow-up/deduplication rationale. However, it does not explicitly name alternatives or state when not to use this tool.

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

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

The description goes well beyond the annotations, detailing that drafts are generated via MCP sampling, that no API key lives here, that all manual send safeguards still apply, that dry_run defaults to true, that it stops at the daily cap, and that failed drafts are skipped. This is exemplary disclosure for a destructive, non-idempotent 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 organized into clear paragraphs and front-loads the core purpose before explaining mechanics. It is slightly longer than strictly necessary, but every paragraph adds meaningful operational or safety context for a destructive batch tool.

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

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

The description covers what happens with drafts, send-path constraints, dry-run behavior, stopping conditions, and failure handling. An output schema exists, so return values need not be described. This is complete for the complexity of the tool.

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

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

Schema description coverage is 100%, so the schema already explains all four parameters. The description reinforces dry_run's default safety and mentions daily-cap behavior, but it does not add substantial per-parameter meaning beyond the schema. Baseline 3 is appropriate.

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

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

The opening sentence specifies the verb and resource: 'Draft and send for several leads in one call, unattended.' It clearly distinguishes this batch tool from siblings like send_message and next_outreach_batch by emphasizing unattended multi-lead operation and MCP sampling.

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 conveys context: use this for several leads, unattended, in a scheduled job without human turn-taking. It does not explicitly name alternatives or say 'use send_message for a single lead,' so it stops short of a 5, but the context is unambiguous enough 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?

The annotations declare readOnlyHint=true, but the description says results are 'saved to the local database automatically' and the refresh parameter 'forget[s] this query's saved progress and records and re-scrape[s].' These are state-modifying behaviors that directly contradict the read-only annotation. While the description transparently discusses caching and resume behavior, this is an annotation contradiction.

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

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

The description is well-structured in three tight paragraphs: behavior and output, URL input workflow, and resume semantics. It is front-loaded with the most important operational facts and every sentence carries useful information, with 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 and full parameter documentation, the description only needs to add workflow and behavioral context, and it does so thoroughly. It explains the summary return, database persistence, valid URL inputs, resume behavior, and refresh semantics. Nothing needed to call or understand the tool is missing aside from the annotation conflict.

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 provides 100% parameter documentation, so the baseline is 3. The description adds practical meaning for search_url by explaining how to build the search and copy the URL, and it notes that saved account lists are accepted. This goes beyond the schema's path list and gives the agent actionable guidance for constructing a valid parameter value.

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

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

The first sentence clearly identifies the operation and resource: searching Sales Navigator companies/accounts and capturing API responses. It also clarifies the output contract (summary only, not records), which distinguishes it from export_results/get_results. The account scope differentiates it from the sibling search_contacts.

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

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

The description gives a concrete workflow: build the Sales Navigator search, copy the URL, and pass it in, with saved account lists also supported. It explicitly directs users to export_results or get_results for the actual records. It does not explicitly contrast with search_contacts or mention when not to use this tool, but the account-scoped intent 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?

The description transparently discloses important behavior: results are saved to a local database, re-calling with the same URL resumes from the next page, and refresh forgets saved progress and records. However, this directly contradicts readOnlyHint=true, which signals that the tool makes no observable state changes; the description describes writes and clearing of saved records observable via get_results/list_queries. This is an annotation contradiction.

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 paragraphs are front-loaded with the core purpose and output, followed by the usage recipe and the resumability caveat. Every sentence contributes a fact needed for correct invocation, 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?

For a stateful, browser-driving tool with six parameters and an output schema, the description covers prerequisites (logged-in browser), input construction, output behavior, alternative retrieval, and rerun/resume/refresh semantics. Nothing needed to call it correctly is missing, and the output schema accounts for the return shape.

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

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

Schema description coverage is 83%, so the schema already documents most parameters. The description adds real meaning by explaining that search_url can be a people/leads search or a saved list URL and by tying pages/resume/refresh to the URL-hash resume mechanism. It does not add semantics for depth, but the enum/default covers that well.

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

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

The description opens with a specific verb-resource pair: 'Search people/leads by driving Sales Navigator...' and immediately distinguishes itself from data-retrieval siblings by stating it returns a small summary, not the records. This clearly separates it from export_results/get_results and search_accounts.

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

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

It gives an explicit workflow: build the search in Sales Navigator, copy the URL, pass it here, and notes saved lead lists also work. It also routes the agent to export_results or get_results when the actual records are needed. It lacks an explicit exclusionary pointer to search_accounts for account searches, so it stops short of a 5.

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

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

Annotations already signal non-read-only, idempotent-false, and destructive behavior, but the description adds substantial context beyond them: dry_run defaults true, server-side sending must be enabled, already-messaged leads are refused, a 24h cap applies, InMail credits may be spent, and evidence_used must resolve against stored fields. This is exactly the behavioral detail an agent needs.

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

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

The description is tightly structured with a front-loaded purpose and a bulleted list of guardrails. Every bullet conveys a distinct operational constraint, and there is no filler or repetition of schema content.

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

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

Given the tool's side-effecting nature, the description covers all critical operational constraints: dry-run safety, server-side enablement, duplicate prevention, rate limiting, credit risk, and grounding requirements. An output schema exists to cover return values, so no essential 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?

Schema coverage is 100%, so the baseline is 3. The description adds meaningful semantics for several parameters: it explains dry_run behavior and return value, that evidence_used must reference real lead-record fields, and that member_id comes from next_outreach_batch. This goes beyond the schema descriptions without repeating them.

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 'Send ONE Sales Navigator message. Writes to LinkedIn,' naming a specific verb, resource, and scope. It also distinguishes itself from siblings by explicitly calling itself the only non-read-only tool here, so an agent can tell it apart without inspecting other schemas.

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

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

It clearly states when this tool is appropriate: to send a single Sales Navigator message and to perform the one write action in this toolset. It gives strong context around guarded sending and refusal conditions, though it does not explicitly name an alternative batch-send tool such as run_outreach_batch.

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