Generect Live API MCP Server

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

Annotations already declare readOnly/idempotent/openWorld, so the bar is lower, yet the description still adds real billing behavior: the call never spends credits, and a realtime count costs $0.04 at Tier 0 list price. It omits latency and result shape, but the output schema covers the latter.

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

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

Three sentences with the core purpose front-loaded and no filler. The 'As with count_leads' cross-reference is slightly indirect and forces the agent to consult another tool's text to resolve the pricing claim, costing it a point.

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 23-parameter tool with full schema coverage, an output schema, and complete annotations, the description supplies the missing piece an agent most needs before calling: the cost model and its position in the search workflow. Filter-level caveats (realtime-only fields, vocabulary validation) are already carried by the schema.

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

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

Schema coverage is 100%, so the baseline is 3; the description earns an extra point by explaining the cost consequence of the mode parameter (realtime is the only path that bills, at $0.04). It does not add anything about the 20+ filter parameters, which the schema already documents 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?

States a specific operation (count companies matching an ICP) plus a second concrete output (the credit cost of pulling them), and positions itself explicitly as 'the first step before search_companies'. That distinguishes it from both search_companies and count_leads without requiring an agent to open any 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 first step before search_companies' plus the note that realtime runs only when mode:"realtime" is passed explicitly gives clear sequencing and mode guidance. It stops short of naming when NOT to use it (e.g. use search_companies when you actually need rows), so it doesn't reach 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?

Beyond the readOnly/idempotent annotations, the description discloses the economics that matter for this API: the call never spends credits, the $0.04 flat realtime price at Tier 0, and the fact that realtime runs only when explicitly requested. The consistency between 'never spends credits' and readOnlyHint=true reinforces trust rather than contradicting it.

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

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

Three sentences, front-loaded with the core outcome, then the free/paid distinction, then the realtime cost caveat. Every sentence carries weight; the only mild inefficiency is the slightly convoluted first clause ('what pulling them would cost at this account's prices').

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 36 parameters, a 100% documented schema, and an output schema present, the description does not need to restate filters or return shape. It covers the two things the schema cannot: that the default path is free and that realtime billing is opt-in. A brief note on the two-level ICP (company_filters) would have made it fully complete.

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

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

Schema coverage is 100%, so the baseline is 3 and the schema already documents mode, strict, exclude_ids and the rest in depth. The description still adds value the schema does not: the concrete realtime price and the warning that passing mode:'realtime' is what triggers billing, which turns an enum choice into a cost decision.

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 resource and outcome — how many leads match an ICP and what pulling them would cost — and explicitly separates itself from search_leads ('the first step before search_leads'). Even though it is phrased as a question rather than a verb, an agent can immediately tell this is a sizing/counting tool, not a row-returning one.

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 clear routing logic: use this first to size an audience for free, then call search_leads to actually pull rows, and avoid mode:'realtime' unless you accept a $0.04 charge. The one gap is that the sibling count_companies (the company-side equivalent) is never mentioned, so the leads-versus-companies choice is left implicit.

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 safety (destructive/openWorld/readOnly), so the description's real contribution is the event payload content and the credit-cost guarantee, both of which are useful and not encoded anywhere else. It stops short of noting that a previously registered URL is replaced or that the URL is validated against private addresses.

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

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

Three sentences, each carrying distinct information: what it registers, what arrives in the event body, and the cost profile. Front-loaded and free of 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?

With an output schema present and annotations covering safety, the description covers purpose, payload, and billing, which is enough for correct invocation. The only gap is what happens on re-registration or duplicate URLs.

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

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

Schema coverage is 100% and every parameter, including the SSRF guard on url, is documented in the schema. The description adds no field-level semantics beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource ('Register a URL that receives bulk-job completion events') and scopes it to the bulk-job event family, which an agent can distinguish from the sibling webhook tools (list_webhooks, test_webhook, update_webhook, delete_webhook).

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 'instead of polling' phrasing implies when a caller would want this, but no sibling alternative or exclusion is named and no precondition for using it over test/update is given. Usage is inferable 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 annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is covered. The description adds useful behavioral context beyond annotations: the endpoint stops receiving completion events, and the call never spends credits.

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

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

Two short sentences, front-loaded with the action and its effect. The cost note is brief and relevant, with no wasted phrasing.

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

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

Given the simple two-parameter schema, full schema description coverage, destructive annotations, and the presence of an output schema, the description is largely complete for correct invocation. It could still say more about selecting this tool over update_webhook or test_webhook, but that is a usage-guidance gap rather than a missing operational detail.

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 the required 'id' and optional 'timeout_ms' are already documented in the schema. The description adds no parameter-specific meaning, which is acceptable at 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 description states a specific verb and resource: 'Delete a registered webhook,' and adds the consequence that the endpoint stops receiving completion events. It is clearly distinct from most siblings, but it does not explicitly differentiate itself from related webhook tools such as update_webhook or test_webhook.

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

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

It does not say when to use this tool versus alternatives like update_webhook or test_webhook, nor does it mention prerequisites or exclusions. The action is implied by 'Delete,' but no real routing guidance is provided.

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

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

Goes well beyond the annotations: discloses that the call is billable at ~$0.02 per record found, that not-found is refunded, that account-specific pricing is retrievable via get_balance, and that the actual charge appears in cost.amount_charged_usd. That is exactly the financial context an agent needs before spending.

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

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

Front-loaded with identity and price, and dense with useful detail. Mild redundancy: "(not-found is refunded)" is restated by "Not found costs nothing".

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 contents need not be described, and cost, identifiers, and modes are covered. The one gap is that all seven parameters are optional and the description never says at least one identifier must be supplied.

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

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

Schema coverage is 100%, so baseline is 3; the description adds genuine value by ranking identifier reliability (id > domain > fuzzy name) and pointing at the cost field. Mode/compact semantics live in the schema rather than the description, so it does not fully exceed 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?

States a concrete verb and resource ("Full profile for one known company") and enumerates the four accepted identifiers. The singular, known-entity framing implicitly separates it from search_companies, but no sibling is named 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?

Gives real selection guidance on identifiers — domain is the most reliable after id, name matching is fuzzy — and the schema's mode description explains database vs realtime vs auto. It does not explicitly say when to prefer search_companies or resolve_profile over 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?

Discloses billing behavior in detail (about $0.02 per found record, refunded on not-found, account-specific pricing via get_balance, actual spend in cost.amount_charged_usd) plus the auto-mode escalation rule and its spend ceiling — none of which is in the annotations. Annotations cover open-world/non-destructive traits; the description adds the cost and escalation context an agent needs before calling a billable 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?

Front-loaded with purpose and identifiers, then cost, then escalation/routing — a sensible order with no filler. The pricing clauses are dense but each carries decision-relevant information for a billable call.

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

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

An output schema exists so return values need no explanation, and the description covers the remaining gaps an agent would care about: cost, refunds, escalation behavior, identifier preference, and the bulk alternative.

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 still adds ranking guidance by saying the `id` is the most accurate identifier and framing email as reverse lookup, which the schema does not state. It does not elaborate on `mode`, `compact`, or `timeout_ms`, but those are already fully documented in the schema.

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

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

States a specific verb+resource ('Full profile for one known person') and enumerates the accepted identifier types, including that email is a reverse lookup. This clearly separates it from list-style siblings like search_leads and preview_leads.

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 routing guidance: use the `id` from search/preview for accuracy, and use start_bulk_job for many people at once. However, it never distinguishes itself from closer siblings like get_lead_by_url or resolve_profile, which appear to overlap substantially.

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 substantial context beyond the annotations: a concrete price (~$0.4 per hit, misses free), the Tier 0 list-price caveat, the per-account variance and how to check it, and where the actual charge appears in the response (cost.amount_charged_usd). That is exactly the billing disclosure annotations (readOnlyHint=false, destructiveHint=false, openWorldHint=true) do not 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?

Front-loads the purpose, then pricing, then the volume guidance — a sensible order with no filler. The pricing paragraph is slightly long (list price, account rate, response field all in one breath) but each clause carries real decision value.

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

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

Given an output schema and annotations, the description covers scope, cost, and volume routing well. The remaining gap is input-side: with zero required parameters, an agent gets no hint here about which identifier combination is valid, relying entirely on schema text.

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 every parameter including lead_id being "the cheapest and most accurate identifier." The description adds nothing about the name+domain vs name+company modes or the fact that all seven parameters are optional and must be combined, so 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?

Opens with a specific verb and resource scoped to a single person: "Find a phone number for one person." It also implicitly separates itself from the sibling contact tool by referencing "an email lookup" and from list workflows by naming start_bulk_job, so an agent can place it without opening the schema.

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

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

Gives an explicit selection rule: it suits already-qualified people "rather than a whole list," and routes list work to start_bulk_job. It also offers get_balance as the alternative for account-specific pricing, covering both the when-to-use and the where-to-look-next questions.

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?

Goes well beyond the annotations (readOnlyHint=false, openWorldHint=true) by disclosing the cost model: ~$0.02 per valid email, free on a miss, tier list price, per-account variance, and the exact response field cost.amount_charged_usd for actual spend. This is precisely the billing/consumption context an agent needs before calling a metered, non-read-only 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?

Front-loads the purpose in a five-word sentence, then layers billing, identification, and batch routing in a tight block with no filler. Slightly dense — the billing and routing clauses are packed into one paragraph — but every sentence carries 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?

An output schema exists, so return values needn't be explained, and the description still calls out cost.amount_charged_usd for the one field agents care about. Billing, identifier modes, and bulk escalation are all covered; the only gap is that with 0 required parameters it never states that at least one identifier must be supplied.

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 genuine selection guidance by declaring lead_id "most accurate" and spelling out the three identification forms (lead_id, LinkedIn URL, name+domain). It does not document timeout_ms or explain why zero parameters are marked required, but it meaningfully enhances the already-documented 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?

States a specific verb and resource: "Find and verify a work email," which is immediately actionable. It does not explicitly distinguish itself from the closest sibling validate_email (which checks an email you already have), so an agent must infer that boundary from names alone. Clear but not sibling-differentiated.

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

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

Explicitly ranks identifier modes ("lead_id (most accurate)"), explains that `candidates` handles several people in one call, and routes requests over 10 to an async bulk job that "returns a job_id for get_bulk_job." It also names get_balance for account-specific pricing, leaving nothing ambiguous about which tool to invoke next.

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

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

Beyond the readOnly/idempotent annotations it discloses cost behavior ('this call never spends credits') and, critically, the spending-order and coverage rules for grants — grants are consumed first, only on covered operation types, and never pay for phone numbers, so balance_usd + grants_usd overstates spendable funds. It also flags that returned prices are the account's real rates versus the list prices shown in other tool descriptions.

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

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

Front-loaded with purpose and the free-cost caveat, then the non-obvious grant semantics. Every sentence carries information an agent would otherwise get wrong, though the grant explanation runs long and is denser than needed for a routine balance 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, so return-shape detail is not required, and the description still explains the two headline fields and why they cannot simply be summed. Combined with zero required params and 100% schema coverage, an agent has everything needed to invoke and interpret this 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 each of the five flags (include_usage, include_prices, include_transactions, include_token_analytics, timeout_ms) is already documented with its own meaning and default. The description conveys that usage and prices are part of the result but never maps that to the optional flags, so it adds little over 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 opening clause names the exact resource and the three things returned (wallet balance, month-to-date usage, account-specific per-operation prices), plus the cost property ('Free: this call never spends credits'). No sibling in the list covers account/billing state, so it is unambiguous against count_leads, health, etc.

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

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

It gives concrete usage contexts: 'before a batch of paid work (what the user can afford) and after it (what was spent)'. That is a clear when-to-use signal. It stops short of naming alternatives or stating when not to call (e.g. whether include_usage makes a separate usage tool unnecessary), so it is not a full 5.

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

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

Annotations already cover readOnly/idempotent, and the description adds genuinely new behavioral context: the call never spends credits and the billable work happened at submit time, so an agent knows repeated polling is safe and cost-free. It does not describe the possible job states (pending/failed/completed) or what happens on an unknown job_id, leaving some behavioral gaps.

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

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

Two short sentences, front-loaded with what is returned followed by the cost/polling note. Slight redundancy between 'never spends credits' and 'Polling is free', but nothing is wasted overall.

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

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

An output schema exists, so return values need no explanation, and the cost/polling guidance covers the main operational concern. The main missing piece is how to interpret status values and when to stop polling, which is a moderate rather than critical 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 description coverage is 100%, so job_id, job_type and timeout_ms are already documented with their enum values and origin at submit. The description adds no parameter-level meaning, so 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 first sentence names the resource (a bulk job) and what it returns (status and results), which separates it from start_bulk_job by referring to work 'billed at submit time'. It stops short of explicitly naming start_bulk_job as the counterpart, so differentiation is implied rather than stated.

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 actionable polling cadence ('a few seconds between polls is enough') and states the call is free, which implies 'use this to poll after submitting'. However it never states when not to use it, how to know when to stop polling, or names start_bulk_job as the required predecessor.

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 billing behavior: roughly $0.02 per found record, refunds for not-found results, tiered account-specific pricing, and the exact response field cost.amount_charged_usd that reports actual spend. It also points to get_balance for account pricing. Those details materially help an agent understand cost implications before invocation.

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

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

The description is front-loaded with the alias identity and then adds pricing and sibling comparison. Every sentence is relevant, though the pricing and cost-reporting detail is somewhat dense and could be trimmed slightly without losing key information.

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

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

Given the rich input schema, 100% parameter coverage, annotations, and the existence of an output schema, the description supplies the additional context an agent needs: alias status, backward-compatibility purpose, billing implications, and the main alternative. Return value details are appropriately omitted because the output schema covers them.

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 parameter documentation is already complete. The description reinforces the URL input and notes that enrich_lead additionally accepts id/email, but it adds no meaningful detail about mode, compact, timeout_ms, or the deprecated ignored parameters. 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 immediately states that this is an alias of enrich_lead scoped to a LinkedIn profile URL. It explicitly distinguishes the tool from enrich_lead, which accepts a Generect id or email, so an agent can identify both the verb and the narrower resource scope without opening the schema.

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

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

It explains that the tool is kept for backwards compatibility and that enrich_lead does the same plus accepts id/email, which gives clear context for when enrich_lead is the better sibling. It stops short of an explicit 'use enrich_lead for new integrations' exclusion, so the guidance is strong but not fully prescriptive.

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 only declare readOnly/idempotent/openWorld; the description adds the trait that actually matters for an agent's routing decision — zero credit cost and no paid-endpoint contact — plus the default-on credential check against a free endpoint. That is substantive, non-redundant behavioral context.

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

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

Short, front-loaded, with the cost guarantee stated immediately after the one-word purpose. Slight redundancy between 'never spends credits' and 'never touches a paid data endpoint', though the latter also introduces the monitor-safety use case.

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 is trivial to call (0 required params), annotations cover the safety profile, and an output schema exists to describe what is reported. The description covers the one thing structured fields cannot express — that calling it is free — so nothing an agent needs 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 both parameters are already fully documented, including the 'Default true' note that 'unless disabled' merely restates. The description adds no format, unit, or edge-case meaning beyond the schema (timeout_ms is never mentioned), so baseline 3 applies.

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

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

States a specific verb and resource ('Liveness check... confirms the MCP server is up, reports its version') plus a secondary behavior (credential verification). This is unmistakably distinct from every sibling, all of which are paid data/enrichment 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?

'Free: this call never spends credits' and 'safe for monitors' give a clear condition for calling it. It stops short of explicitly routing the agent away from siblings (e.g., 'use get_balance for remaining credits, not this'), so it lacks an explicit alternatives clause.

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

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

Annotations already cover readOnly/idempotent, so the description's value-add is the credential-cost disclosure ('never spends credits') and the scope limitation that only bulk-job completion endpoints are returned. It does not address the openWorldHint implication (results can change externally), which keeps it below a 5.

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; the scope constraint comes first and the free-call reassurance second. No repetition of the title and 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?

With an output schema present, return values need not be described, and the annotations carry the safety profile. What remains slightly uncovered is pagination/result-size behavior for a potentially open-world list, but otherwise the definition is sufficient to call 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?

There is a single optional parameter (timeout_ms) at 100% schema description coverage, so the schema fully documents it. The description adds nothing about timeout behavior, and per the baseline rule this is a 3.

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

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

Names a specific verb and resource (list / webhook endpoints) and narrows the scope to endpoints registered for bulk-job completion events, which is a meaningful qualifier. The verb alone already separates it from create_webhook, delete_webhook, update_webhook and test_webhook, so no explicit sibling routing is needed.

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 to see which webhooks are registered. The 'Free: this call never spends credits' note is a useful cost signal that lowers the bar for calling it, but there is no explicit when-not or pointer to alternatives (e.g. use test_webhook to verify delivery).

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 substantial context the annotations do not carry: per-row pricing (~$0.002), that per-account rates differ and where to verify them (get_balance) and confirm actual spend (cost.amount_charged_usd), and the contract-level masking of LinkedIn URL, domain, email and phone. This is exactly the billing and output-fidelity information an agent needs before spending money on a non-readOnly 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?

Five sentences, all load-bearing: purpose, price, account-specific price, workflow, and output masking, in roughly decreasing order of importance. The closing sentence ('an account that gets more than that cannot rely on it') is awkwardly and ambiguously phrased and could be stated plainly.

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 41-parameter, billable tool with an output schema and full schema coverage, the description supplies the missing conceptual layer: cost model, spend confirmation path, masking, and the intended multi-step workflow. It leaves the relationship to search_leads and pagination strategy to the schema, which is defensible but a small 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 description coverage is 100% and the parameter descriptions themselves are unusually rich (pricing per limit_by row, realtime-mode triggers, deprecated flags). The description adds no parameter-level meaning beyond what the schema already states, so the baseline 3 applies.

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

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

The description frames the tool precisely as a cheap sample of the people behind a count, before a full search, and names the downstream steps (enrich_lead, generate_email). It distinguishes itself from a full search conceptually, but never names search_leads or count_leads directly, leaving the agent to infer which sibling is the 'full search'.

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 an explicit workflow (preview many, pick the few that fit, then enrich only those) plus the free count_only escape hatch and the caveat that rows are masked so richer accounts cannot be assumed. It stops short of stating the negative case by name, e.g. 'use search_leads when you need unmasked LinkedIn URLs or emails'.

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 only give the generic readOnly/openWorld/destructive triad, while the description discloses the traits that actually matter here: billability at ~$0.0005/resolved profile, free unresolvable references, per-row billing for duplicates, per-account pricing via get_balance, and where the actual charge appears (cost.amount_charged_usd). That is exactly the context annotations cannot carry.

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

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

Front-loaded with purpose, then cost, then inputs, then downstream use — a sensible order with no filler. It is dense and slightly long, with parenthetical billing caveats that take a second read, but every sentence carries information an agent needs.

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 billable resolution tool with an output schema and full param documentation, the description covers inputs, cost model, batch semantics, output identity scope, and the handoff to sibling tools. An agent can decide whether to call it and how to chain it without further discovery.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds real meaning beyond the schema: it enumerates the accepted input flavours (obfuscated ACwAA links, Sales Nav lead URLs, bare ids, urns), notes the 50-item batch cap, and — crucially — states that the numeric member id is rejected with a 403, a constraint absent from 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 first sentence names a specific verb and resource ('reveal who is behind an anonymous LinkedIn profile link') and the rest scopes it precisely: identity only, no location/company/history. It is clearly distinguishable from enrich_lead, which the description explicitly names as the tool for the deeper fields.

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

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

It states when to use it ('the cheap first step before a full record'), names the alternatives and their differing scope (enrich_lead has location/company/work history), and describes the downstream chain (the returned `id` is accepted by enrich_lead, generate_email, find_phone). It also states a when-not: the numeric member id is not accepted as input.

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?

Goes well beyond the annotations: discloses the daily free-row quota and its 00:00 UTC reset, exact full-row price (~$0.02), the $0-for-zero-rows rule, where the actual charge is reported (cost.amount_charged_usd), what thin rows omit (no domain), and that headcount_range is an indexing-time snapshot that can lag. This is precisely the billing and data-quality context an agent needs before spending.

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

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

Five sentences, cost model front-loaded and no filler. Dense but each sentence carries pricing, quota or data-quality information; the headcount-range caveat at the end is slightly buried for an operational warning.

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

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

Output schema exists, so return values needn't be explained, and the description fully covers the cost/quota/detail dimensions that matter most for a 30-parameter billable search. The mode/auto-escalation and spend-ceiling behavior are left entirely to the schema, which is acceptable but means the description alone wouldn't tell an agent how mode selection interacts with the billing story.

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 detail enum already documents thin vs full at length, so the description largely restates it. It does add two things not in the schema: thin rows lack domains and enrich_company fills them, and headcount_range is applied at query time despite being an indexed snapshot — but this is marginal against an already-exhaustive 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?

States a specific verb+resource ("Return companies matching an ICP") and immediately frames the cost/detail model that distinguishes it. Sibling differentiation is partial — count_companies is named as the free sizing step, but search_leads/enrich_company are only referenced in passing rather than contrasted.

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 actionable routing: "count_companies sizes the result for free first" and "Browse thin, then spend only on the rows you keep," which names the cheaper alternative and the pay-only-for-what-you-keep pattern. No explicit when-not-to-use clause, and the database-vs-realtime choice lives in the schema rather than the description.

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

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

Goes well beyond the annotations (readOnly false, openWorld true, destructive false) by disclosing pricing (~$0.02/row, 0 rows costs $0), the daily free thin-row quota with 00:00 UTC reset, a 429 on a spent thin quota, the per-call spend ceiling and confirm_spend refusal threshold, realtime escalation cost, and that every response reports cost.amount_charged_usd. It also warns that ordering is unstable — behavior no annotation could 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?

Front-loaded on what is returned and what it costs, then guidance, then the data caveat — a sensible priority order. Slightly dense in the middle (realtime/escalation billing sentence is compressed and needs a second read), but no sentence is 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 43-parameter search tool with an output schema and full annotation coverage, the description covers the things the schema cannot: cost model, free-tier quota behavior, escalation, contact-field gaps and pagination strategy. Nothing needed to call it safely or 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%, so the schema carries mode/detail/limit_by semantics and the baseline is 3. The description still adds rate context the schema lacks — Tier 0 list price vs the account's actual rate via get_balance — plus the pagination rationale behind exclude_ids and the missing-email/phone constraint on returned rows.

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 — 'Return leads (people) matching an ICP' — and the title immediately frames the free-vs-billed distinction that separates it from count_leads, enrich_lead and search_companies. An agent can tell what it produces (lead rows, no email/phone) without opening the schema.

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

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

Explicitly routes the agent: 'count_leads sizes the audience for free first', 'Browse thin, then spend only on the rows you keep', generate_email/find_phone for contacts on kept ids, and exclude_ids instead of offset for paging. Both the cheap path and the alternatives are named with the condition that selects them.

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 substantial behavioral context beyond annotations: billing at the single-record rate, reservation of the whole cost at submit time, and continued charging even if nobody polls the job. This is exactly the kind of billing and lifecycle disclosure an agent needs for a non-destructive but billable asynchronous operation.

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

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

The description is front-loaded with the core action and result, then covers cost, approval, and follow-up mechanisms in a compact sequence. Every sentence adds useful information 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?

Given the tool's complexity, output schema, and annotations, the description covers the essential lifecycle: asynchronous submission, job_id, billing reservation, approval expectation, polling via get_bulk_job, and webhook notification. Nothing critical for correct invocation appears to be 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 parameter details are already well documented in the schema. The description reinforces the 50-record limit and job_id return but does not add parameter-specific meaning beyond what the schema provides.

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

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

The description states a specific verb and resource: submit up to 50 records for asynchronous processing and get a job_id back. It clearly distinguishes this bulk asynchronous tool from the single-record tool and from get_bulk_job, which polls the submitted job.

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 explains that the tool is meant for a list the user has approved and names get_bulk_job for polling and create_webhook for completion notification. However, it does not explicitly state when to choose this over repeatedly calling the single-record tool, beyond the 50-record batch limit.

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 declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is partly covered. The description adds genuinely useful context beyond that: the call never spends credits, which an agent cannot infer from annotations. It stops short of disclosing that a real HTTP request is delivered to the customer's endpoint or what payload is sent.

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 waste; the action is front-loaded and the cost caveat follows immediately. Nothing is padded or repeated from 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?

An output schema exists and both params are documented, so the description needn't explain return values. The remaining gap is what the test event actually contains and whether the endpoint's response affects the result — useful but 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% and both parameters are documented in the schema, including the cross-reference to list_webhooks for the id. The description adds no syntax, defaults, or timeout semantics beyond that, so baseline 3 applies.

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

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

States a specific verb and resource: 'Send a test event to a registered webhook endpoint.' An agent can distinguish it from create_webhook/update_webhook/delete_webhook, though the description never names those siblings explicitly to reinforce the 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?

Implied usage is clear — verifying a registered webhook works — but there is no explicit when-to-use rule, no prerequisites (does the webhook need to be enabled?), and no stated alternative such as re-sending a real event.

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 declare destructiveHint=true and openWorldHint=true, and the description adds real value beyond them: the 'never spends credits' cost note and an explanation of the consequences of changing URL (delivery target) and events (what gets sent). It stops short of clarifying irreversibility or that a new secret invalidates existing signature verification, which matters for a destructive mutation.

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

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

Front-loads the action, then the cost note, then effects. Mostly tight, though the trailing clause ('and the results they carry') and the URL/event effect sentence lean toward restating the obvious.

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 full schema coverage, the description needs only the behavioral layer, and it largely provides it (cost, effect of changes). It could note irreversibility or secret rotation impact, but is otherwise sufficient to call correctly.

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

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

Schema coverage is 100%, so the schema already documents all five parameters, including the private-address refusal for url and the minItems:1 constraint for events. The description only restates the effects of url/events changes, adding marginal 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?

Clear verb (Change) + resource (webhook settings) with the three updatable fields spelled out. 'Registered webhook' implies an existing resource, loosely distinguishing it from create_webhook, but no sibling is named 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?

Usage is implied by 'registered webhook' (you need an existing one, id from list_webhooks) and the cost note helps prioritization, but there is no explicit when/when-not guidance or routing against create_webhook/delete_webhook.

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?

Goes well beyond the annotations: discloses per-address billing regardless of verdict, the approximate Tier 0 price ($0.005), that account-specific rates exist and are retrievable via get_balance, and that actual spend appears in cost.amount_charged_usd. The readOnlyHint=false / openWorldHint=true annotations are consistent with a billable external lookup; 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?

Purpose is front-loaded, followed by pricing and then the re-validation caveat. The billing point is restated twice ('every address is billed' and 'every submitted address is billed'), which is slightly redundant but defensible given the cost implication.

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 needn't be explained, and the description still names the cost field to look for. Billing, pricing lookup, and the duplicate-validation pitfall are all covered; an agent has everything needed to call it responsibly.

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%, including 'Each one is billed' for emails, so the schema already carries parameter meaning. The description reinforces the billing-per-address semantics but adds nothing about timeout_ms or input format. Baseline 3 is appropriate when the schema does the heavy lifting.

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+resource and scope: 'Check deliverability of emails you already have'. The qualifier 'you already have' distinguishes it from the sibling generate_email, which produces addresses rather than validating existing ones.

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 warns against re-validating addresses that generate_email already returned as valid, which is a real when-not-to-use rule. It also routes pricing questions to get_balance. It doesn't contrast with enrich_lead or enrich_company, which may also surface validation-adjacent data, so it stops short of full sibling routing.

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