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

No annotations are supplied, so the description carries the full behavioral burden. It does disclose one useful security-relevant trait, namely that only encrypted storage state is persisted, but it says nothing about failure behavior when verification fails, whether existing sessions are overwritten, or what permissions or environment requirements this needs. That is a substantial gap for a tool that stores credentials-derived state.

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

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

A single front-loaded sentence with no filler, and the most important qualifier, 'manually completed', appears early. Every clause earns its place.

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

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

With no annotations, no output schema, and an undocumented parameter, the description has to do more work than one sentence allows. It never covers prerequisites, failure modes, or the result of verification, which an agent needs before invoking a state-mutating auth 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?

There is one required parameter, provider, and the description never mentions it. The schema has zero description coverage, so the description should compensate, but the enum of linkedin and naukri makes the value set self-evident enough that the practical risk of misuse is low. Baseline is a 3 because the enum carries the meaning the description omits.

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 pairs a specific verb with a specific outcome: it verifies a manually completed provider login and persists encrypted browser storage state. That distinguishes it from start_browser_login and get_browser_auth_status in substance, although 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?

'Manually completed' implies this is the step after a human finishes a login flow started elsewhere, but the description never says to call it after start_browser_login, never states the precondition that login must already be done in the browser, and never mentions what to do instead if no login is pending.

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

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

With no annotations, the description carries the full burden; it does disclose the categories of information returned (support status, access requirements, fragility), which is meaningful behavioral context for a discovery tool. It does not state that the call is read-only/side-effect free, whether it hits the network per provider, or how results are shaped, leaving gaps an agent would want closed.

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

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

One front-loaded sentence with the verb first and no filler; every clause adds a distinct information category. It is terse to the point of under-specification rather than verbose, which is the right shape but leaves little room for guidance.

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, no-output-schema, no-annotation discovery tool, the description covers what is returned at a high level but not how to interpret or act on it (e.g., what "fragility" means for a downstream call, or default behavior for the optional provider). Adequate but missing the interpretive context that makes a discovery tool actionable.

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

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

The single parameter has 0% schema description coverage, but its enum values (linkedin, naukri) are echoed in the description text, so the agent can map the argument to a provider. The description does not say the parameter is optional or what happens when it is omitted (all providers vs. error), which is the main semantic gap.

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

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

The description gives a specific verb ("Discover") and a specific subject (runtime support, access requirements, fragility for LinkedIn and Naukri operations), so the agent can tell this is a capability-probing tool rather than a search or mutation tool. It does not explicitly name which sibling it complements (e.g., the preview_* / execute_confirmed_mutation tools that would consume its output), which keeps it below a 5.

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

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

Usage is only implied: the word "Discover" plus "operations" suggests calling this before attempting LinkedIn or Naukri actions, but the description never says when to call it, whether it should precede mutations, or what to do with the result. No exclusions or alternative tools are mentioned.

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

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

With no annotations, the burden falls entirely on the description, and it discloses non-obvious behavior: previews are single-use even when execution fails, and the preview must be unexpired. The 'exact' wording hints at hash matching as a guard. However, it doesn't say what happens on mismatch or expiry (error shape, retryability), and it never explicitly states the mutation is irreversible.

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

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

Two short sentences with no filler. The precondition is front-loaded, and the single-use caveat, the most surprising trait, is placed second with emphasis. 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?

For a destructive mutation with no annotations, no output schema, and 0% parameter documentation, the description covers preconditions and single-use semantics well but leaves gaps: failure/error behavior, what a successful execution returns, and explicit per-parameter meaning. An agent can call it, but will be guessing about outcomes.

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

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

Schema description coverage is 0%, so the description needs to carry parameter meaning. It obliquely explains previewHash via 'one exact ... preview' and confirmation via 'fresh explicit user confirmation,' and operationId via 'one ... mutation,' but never maps those meanings to the parameter names. The format constraints (uuid, 64-hex) are in the schema but their purpose is left to inference.

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 says a specific verb and resource — 'Execute one exact, unexpired mutation preview' — which is unambiguous. It implicitly distinguishes the tool from the many preview_* siblings by framing it as the execution step. It stops short of naming the sibling that produces the preview, but the role is clear.

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 defines clear preconditions: the preview must be exact, unexpired, and preceded by fresh explicit user confirmation. That tells an agent when this tool is appropriate without spelling out 'do not call this to create a preview, use preview_* instead.' No explicit exclusions are given, which keeps it just below the top score.

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

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

With no annotations, the description carries the full burden, and it does add one real safety fact: cookies and credentials are never returned. It still leaves the agent guessing whether the call is read-only in effect, what permissions or configuration it needs, and how the status is expressed, which matters for a browser-auth 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?

A single front-loaded sentence with no filler; the security caveat is attached directly to the action and nothing is redundant.

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?

There is no output schema, so the description is the only place the return value could be characterized, and it never says whether status is a boolean, an enum, or per-provider detail. Combined with no annotations and no guidance relative to the login/logout siblings, it is adequate but leaves meaningful gaps.

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

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

Schema description coverage is 0%, so the description must compensate; it partially does by framing 'provider' as an opt-in browser-auth provider rather than an arbitrary identifier. The enum (linkedin, naukri) is self-explanatory but the description adds no per-provider behavioral notes beyond the qualifier.

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 ('Get ... browser authentication status') scoped to a provider, which is precise enough to act on. It does not, however, distinguish itself from closely related siblings like start_browser_login, complete_browser_login, or logout_browser_session.

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 'opt-in provider' implies this is a pre-check on a provider whose session the user has opted into, but there is no explicit statement of when to call it (e.g., before start_browser_login) or when to use a sibling instead. Usage must be inferred from the name and the surrounding login toolset.

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

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

With no annotations, the description carries the full behavioral burden. "Get" implies a read operation and "public details" hints at non-sensitive output, but it does not disclose auth requirements, rate limits, error behavior, or mutation safety.

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. Every word contributes to identifying the action and resource.

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

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

For a tool with no annotations, no output schema, and 0% schema description coverage, this definition is too thin. It does not explain return shape, provider selection, or how to handle invalid job IDs.

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

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

Schema description coverage is 0%, so the description should compensate for both parameters. It only mentions "provider job ID" and adds no explanation of the provider enum values, jobId format, or constraints.

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

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

The description states a clear verb and resource: get normalized public details for a provider job ID. It distinguishes a detail lookup from broader job searching, but does not explicitly name sibling alternatives such as search_jobs.

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

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

There is no explicit when-to-use or when-not-to-use guidance. The only implied usage is that the caller needs a provider job ID, but it does not explain whether this follows a search or how it differs from search_jobs.

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

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

With no annotations, the description carries the full burden. It does disclose the key scope distinction (local encrypted storage vs. provider security settings), which is genuinely useful. However, it does not say whether the deletion is irreversible, whether active tokens/credentials are invalidated, or whether the user must re-authenticate afterwards.

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, zero waste, with the action stated first and the important scope caveat immediately after. Nothing needs trimming.

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

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

For a single-enum-parameter tool with no output schema, the definition covers the action and its main boundary. The only meaningful gap is post-condition behavior (success indication, need to re-login), which is minor at this complexity.

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

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

There is one required parameter with 0% schema description coverage, but its enum (linkedin, naukri) is self-documenting and the description refers to it as "the selected provider's." It adds no further meaning such as what happens if no session exists for that provider.

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 definition pairs a specific verb ("Delete") with a precise resource ("encrypted local browser session") scoped to the selected provider. It is clearly distinguishable from the login siblings (start_browser_login, complete_browser_login) and from provider-side settings.

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 second sentence effectively states a when-not condition: this will not revoke sessions in the provider's security settings, so an agent knows not to rely on it for revocation. It lacks an explicit positive trigger (e.g., "use when the local session is stale or switching accounts") and names no alternative sibling.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the tool is disabled by default and requires an approved provider mutation capability, which is real context. But it does not state whether the preview is side-effect-free, what auth is required, or what the preview returns, all important for a mutation-preview 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?

Two short sentences, front-loaded with the action, and the second sentence carries necessary gating information. Minor grammar issue ('a application') does not cause bloat.

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

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

The tool has a nested changes payload, two required params, 0% schema description coverage, no annotations, and no output schema. The description covers purpose and capability gating but leaves parameter structure, validation limits, and preview result/next-step behavior unexplained. Incomplete for this complexity.

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

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

Schema description coverage is 0% with two required parameters: provider (enum linkedin/naukri) and changes (nested array of field/operation/value). The description never mentions these parameters or explains what a 'changes' entry means, so it adds no meaning beyond the schema. For a nested mutation payload, this is a significant gap.

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

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

The description states 'Preview a application mutation,' giving a clear verb and resource. It is understandable in context, but 'application mutation' is broad and it does not distinguish this tool from sibling preview tools or explain what application fields may be changed. Clear but not maximally specific.

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

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

It gives a capability precondition: disabled by default and available only when the provider advertises an approved mutation capability. However, it does not explicitly say to use this before execute_confirmed_mutation, nor does it point to discover_provider_capabilities for checking the gate. Usage is implied rather than fully spelled out.

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

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

With no annotations, the description usefully discloses the gating behavior: the tool is disabled by default and requires provider-advertised capability. It does not say whether previewing is side-effect-free read-only, whether changes are applied only after execute_confirmed_mutation, or what a preview result looks like, which are the key behavioral questions for a dry-run 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?

Two short sentences with no filler, and the capability gate is stated up front. The first sentence is slightly ungrammatical ('a education') but that does not impede comprehension.

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

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

For a tool with no annotations, no output schema, and zero schema description coverage, the description does not describe what is previewed, what fields are valid, or what the caller receives back. The capability precondition is the only substantive addition, leaving an agent to guess at the input contract.

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

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

Schema description coverage is 0%, so the description must carry the burden, yet it says nothing about 'provider' (valid values linkedin/naukri) or the 'changes' array. It omits the fact that each change needs a field, an operation of set/remove, and an optional value, and that there is a 25-item cap.

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

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

States a specific verb ('Preview') and resource ('education mutation'), which distinguishes it from the many other preview_* siblings such as preview_profile_update and preview_resume_update. It stops short of saying what the education mutation covers (e.g. degrees, institutions), so the resource is named but not scoped.

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 a real precondition ('Disabled by default and available only when the provider advertises an approved mutation capability'), which implies checking a capability discovery tool first. However, it does not name that sibling (discover_provider_capabilities) or say that preview is the step preceding execute_confirmed_mutation, leaving the workflow sequence 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?

With no annotations, the description carries the full burden. It usefully discloses that the tool is disabled by default and gated by provider capability, but it does not explicitly state that previewing is non-mutating, what the preview returns, or whether changes are validated or persisted.

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

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

The description is two short sentences and is front-loaded with the purpose before the availability caveat. It is efficient, though the grammar ("a experience") is slightly rough and no detail is given beyond the minimum.

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 preview mutation tool with two required parameters, a nested changes array, no annotations, and no output schema, the description is too thin. It covers purpose and availability but omits parameter meaning, expected return behavior, and how the preview relates to the separate execution 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 0%, so the description must compensate for undocumented parameters. It does not explain the provider enum, the changes array structure, field/operation semantics, value handling, or the 25-item limit, leaving the schema to speak entirely for itself.

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: "Preview a experience mutation." This clearly identifies the tool's purpose and distinguishes it from generic mutation tools, though it does not explicitly name sibling preview tools or define what "experience" covers.

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

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

It provides a key availability condition (disabled by default, only when the provider advertises an approved mutation capability), which implies when it can be used. However, it does not mention when to choose this over execute_confirmed_mutation or other preview tools, nor does it describe the intended workflow.

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

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

With no annotations, the description must carry the behavioral burden. It does add genuinely useful availability context: the tool is disabled by default and gated on an advertised approved mutation capability. It stops short of saying whether the preview performs any write, what it returns (a diff? a plan token?), or how it fails when the capability is absent, which matters for a mutation-adjacent 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?

Two short sentences, zero filler, with the purpose front-loaded and the availability constraint immediately following. Every clause carries information the 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?

A nested-array mutation-preview tool with no annotations, no output schema, and zero parameter descriptions needs considerably more than two sentences. The description explains availability but leaves the entire `changes` payload contract and the tool's return/confirmation behavior undocumented.

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

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

Schema description coverage is 0%, so the description needs to compensate and does not. It says nothing about the `provider` enum (linkedin/naukri) or about the `changes` array structure: which field names are legal for job preferences, what `set` versus `remove` does to `value`, or that the array is capped at 25 items.

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

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

The description names a specific verb ("Preview") and resource ("a job_preferences mutation"), so the operation is unambiguous. It does not, however, distinguish itself from the many sibling preview_* tools (preview_profile_update, preview_visibility_contact_update, etc.), leaving the agent to infer that this one is scoped to job preferences only.

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 gating condition ("disabled by default and available only when the provider advertises an approved mutation capability") implies the agent should first consult a capability check, presumably discover_provider_capabilities, but never names it. Likewise it never states that this preview should precede execute_confirmed_mutation, so the preview-then-confirm workflow is only implied.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose an important trait: the tool is feature-gated and off by default unless the provider advertises an approved mutation capability. However, it does not state whether the preview has any side effects, what it returns (a diff or token), or that a separate confirmed-mutation call must follow.

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

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

Two short sentences with zero filler, and the availability constraint is front-loaded after the purpose statement. Nothing is redundant.

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

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

For a simple two-parameter tool the description covers the availability gate but leaves the mutation lifecycle unexplained: what a preview produces and how it connects to execute_confirmed_mutation. With no annotations and no parameter documentation, an agent still has gaps before calling it correctly.

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

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

Schema description coverage is 0%, and the description says nothing about the two parameters. The nested changes array (field/value/operation with set/remove) and the provider enum are only inferable from the raw schema, so the description does not compensate for the coverage gap.

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

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

"Preview a message mutation" names a verb and resource, but "mutation" is vague: it does not tell an agent whether this previews a message send, edit, or delete, even though the tool name says message_send. It fits the sibling preview_* family pattern but lacks explicit differentiation from them.

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

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

The description gives a real gating condition (disabled by default, only usable when the provider advertises an approved mutation capability), which implies calling discover_provider_capabilities first, but it never names that sibling or explains the relationship to execute_confirmed_mutation. No explicit when-not guidance is given.

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

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

With no annotations, the description must carry the behavioral load, and it does convey the two most important traits: the operation is a non-mutating preview and it is feature-gated per provider. It stops short of the important behaviors for a preview tool — what the preview returns, whether it produces a confirmation token/expiry consumed by execute_confirmed_mutation, and whether the preview can fail for unsupported fields.

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 the core action front-loaded and the gating constraint second — no filler. Its brevity is efficient, though it comes at the cost of the parameter and hand-off detail noted elsewhere.

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

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

For a tool with no annotations, no output schema, 0% schema coverage, and a nested changes array, the description leaves too much unsaid. Critically, it never explains how the preview relates to execute_confirmed_mutation, which is the natural next step in a preview/confirm mutation workflow.

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

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

Schema description coverage is 0% for the two required parameters, so the description must compensate and does not: it never mentions `provider`, the `changes` array, the set/remove `operation` semantics, or the 25-item cap. An agent learns nothing about parameter meaning beyond what the raw JSON schema already shows.

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 gives a verb and resource ("Preview a profile mutation"), but "profile mutation" is abstract and the tool sits among many far more specific siblings (preview_resume_update, preview_skills_update, preview_visibility_contact_update). It does not explain what this generic preview covers that those targeted previews do not, so an agent cannot confidently distinguish them.

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

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

The gating condition ("disabled by default and available only when the provider advertises an approved mutation capability") is a real prerequisite that implies calling discover_provider_capabilities first. However, there is no guidance on when to choose this generic profile preview over the section-specific preview_* siblings, nor any exclusion 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?

With no annotations, the description must carry the behavioral burden. It does disclose a meaningful gating trait (disabled by default, capability-dependent), which is genuine added context. But it never confirms that a preview is non-mutating, what it returns, how long a preview stays valid, or what the follow-up confirmation step is — substantial gaps for a gated mutation-adjacent 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?

Two tight sentences with the gating constraint placed immediately after the purpose — no filler, nothing buried, and the most decision-relevant caveat is front-loaded.

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

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

There are no annotations and no output schema, and the description does not cover the preview lifecycle or the nested changes payload. For a tool whose whole value is producing a reviewable preview before a real mutation, an agent is left guessing what it gets back and how to proceed.

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

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

Schema description coverage is 0%, so the description should compensate, and it says nothing about either parameter. The nested 'changes' array (field/operation/value, 1–25 items) and the allowed provider enum are only discoverable by reading the schema. Baseline 3 applies since the schema still fully defines the structure, but no extra meaning is added.

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 ('Preview a resume mutation'), which distinguishes it from the other preview_* siblings such as preview_profile_update or preview_skills_update by naming the resume resource. It stops short of explicitly routing the agent away from those siblings, but the scope is unambiguous.

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

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

It gives a real availability precondition: disabled by default, usable only when the provider advertises an approved mutation capability. However, it never says which tool reveals that capability (discover_provider_capabilities is a sibling) or how the preview relates to execute_confirmed_mutation, so the when-to-use guidance is implied rather than stated.

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

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

With no annotations, the description carries the full burden, and it does disclose the capability-gating and default-disabled state, which is non-obvious and valuable. It stops short of the most important behavioral fact for a preview tool: that it validates without persisting the save, and what the preview returns. That omission is significant given zero annotation coverage.

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

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

Two short sentences, front-loaded with the purpose and followed by the gating condition. Nothing is redundant or padded.

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 preview-safety tool with no annotations, no output schema, and no parameter documentation, the definition is thin. It should state that no mutation is persisted and what a successful preview yields, since nothing else in the structured data conveys that.

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

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

Schema description coverage is 0%, so the description must compensate, and it adds no meaning for either parameter. It says nothing about the `changes` array (per-field set/remove operations, 1-25 items) or the `provider` enum of linkedin/naukri, leaving an agent to infer the payload shape entirely 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 description names a specific verb and resource: 'Preview a save_job mutation.' That distinguishes it from the execution siblings such as execute_confirmed_mutation. It does not explicitly contrast with the other preview_* tools (e.g., preview_application_submission), but the 'save_job' resource is specific enough for selection.

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 supplies a real precondition: disabled by default, available only when the provider advertises an approved mutation capability, which usefully points an agent at discover_provider_capabilities. However, it never states the follow-on flow (that a preview precedes execute_confirmed_mutation) or when an agent should call preview rather than skip it, leaving the workflow implied.

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

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

No annotations are supplied, so the description carries the full burden. It discloses the capability gate, which is genuinely useful, but it never states that the call is non-mutating, what a preview response contains (a diff? a validation result?), or what errors occur for unsupported providers — critical context for a tool literally named 'preview' that sits next to execute_confirmed_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?

Two tight sentences with the core action front-loaded and the availability constraint immediately after. No filler, though the brevity comes partly at the cost of needed detail rather than from disciplined editing.

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 no annotations, no output schema, 0% parameter coverage, and a nested array-of-objects parameter, the description should explain both the preview semantics and the field/operation vocabulary. It covers only the availability gate, leaving most of what an agent needs to call this correctly unstated.

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

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

Schema description coverage is 0%, so nothing in the schema explains the parameters, and the description adds no meaning at all. It does not clarify valid 'field' names for skill mutations, how 'set' vs 'remove' interact with 'value', the 25-item limit, or the provider enum.

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 gives a specific verb and resource ('Preview a skills mutation'), which clearly separates it from the other preview_* siblings such as preview_profile_update or preview_resume_update. It stops short of saying what a preview actually produces, but the action and target domain are unambiguous.

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

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

It states a real gating condition: the tool is disabled by default and only works when the provider advertises an approved mutation capability. However, it never names the sibling that establishes that precondition (discover_provider_capabilities) nor explains the relationship to execute_confirmed_mutation, leaving the agent to infer the workflow.

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

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

With no annotations supplied, the description carries the full burden, and it does disclose one genuinely important trait: the tool is gated off by default behind an advertised capability. It does not say whether preview has side effects, what the response contains (validation errors? a changelog?), or what happens when the capability is missing (error vs. empty result).

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

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

Two compact sentences, front-loaded with the purpose and followed by the availability constraint. No padding or redundancy; the only weakness is the unexplained internal type name in the first clause.

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

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

The tool has a nested, enum-constrained schema, zero annotation coverage, and no output schema, yet the description is two sentences. An agent still cannot tell what a preview returns, which fields are editable, or what to do when the capability gate fails — the gaps sit exactly where the structured data is weakest.

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

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

Schema description coverage is 0% for a two-parameter tool with a nested 'changes' array of field/operation/value objects and a provider enum. The description adds no meaning for 'provider' beyond the schema, and nothing about which fields are valid targets for 'set'/'remove', the 25-item cap, or the field naming convention. It does at least imply the changes target a settings object, but that is thin compensation for a completely undocumented schema.

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

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

The description gives a specific verb+resource pair ('Preview a visibility_contact_settings mutation'), which separates it from siblings like preview_profile_update or preview_resume_update that target other resources. It loses a point because 'visibility_contact_settings' is unexplained jargon rather than a plain-language statement of what is being previewed (contact visibility settings).

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 a real precondition: the tool is disabled by default and only usable when the provider advertises an approved mutation capability. However, it never says how to verify that condition (the sibling discover_provider_capabilities is the obvious candidate) and never states the relationship to execute_confirmed_mutation — i.e. that preview must precede confirmation. Usage is implied rather than spelled out.

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

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

No annotations exist, so the description carries the full behavioral burden. It does hint that some data kinds may not be available for a given provider ('when supported'), but it says nothing about authentication requirements, what happens when an unsupported kind is requested, whether recruiter-message summaries need elevated permissions, or whether the call is purely read-only. For a multi-provider account read with zero annotation coverage, this is a substantial gap.

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

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

A single front-loaded sentence with the verb first and the resource list after; no preamble or filler. The enumeration is long but each item corresponds to a real capability, so it earns its space. Slight redundancy with the `kind` enum keeps it from a 5.

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 two required enum parameters, no output schema and no annotations, an agent can construct a call but cannot predict the response shape, error behavior for unsupported kinds, or auth prerequisites. The description covers the 'what' adequately but not the operational context a multi-provider read tool needs.

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

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

Schema description coverage is 0%, but both parameters are enum-constrained and self-describing, and the description enumerates the `kind` values in prose. The critical semantic gap is the provider × kind matrix: the description never states which kinds are valid for LinkedIn versus Naukri, leaving 'when supported' as an unresolved ambiguity the schema cannot answer. Partial compensation, hence 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?

The description opens with a specific verb ('Read') and enumerates the exact resources available (profile, resume, skills, experience, education, preferences, visibility settings, jobs, applications, recruiter messages), which maps cleanly onto the `kind` enum. An agent can tell this is the read-side tool versus the many `preview_*`/`execute_confirmed_mutation` siblings. It never names a sibling explicitly, so it falls short of a 5.

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

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

There is no when-to-use guidance: nothing says to check `discover_provider_capabilities` or `get_browser_auth_status` first, nor that writes should go through the `preview_*` tools. The only conditional is the trailing 'when supported', which is never defined. Usage is left entirely to inference from the tool name.

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

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

With no annotations, the description carries the full behavioral burden. It discloses only that listings are public and pagination is bounded; it says nothing about authentication/browser-session requirements, rate limits, whether results are scraped live or cached, or whether pagination tokens expire — all relevant given the surrounding auth and mutation tools.

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

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

A single front-loaded sentence with zero filler and no redundant restatement of the name. It is efficient, though the terseness is as much under-specification as conciseness for a 7-parameter tool.

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

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

For a 7-parameter search tool with no annotations, no output schema, and no parameter documentation, the description is far too thin. It should at minimum explain result shape, pagination flow, and prerequisites; none of that is present.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate and largely fails to. It only weakly signals the provider choice and a pagination bound; query, location, remoteMode, postedWithinDays, and pageToken semantics (format, expiry, how to obtain the next token) are entirely undocumented.

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

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

The description gives a specific verb ('Search') and resource ('public LinkedIn or Naukri job listings'), and 'bounded pagination' hints at the limit/pageToken mechanism. It does not distinguish itself from the sibling tools search_linkedin_jobs and search_naukri_jobs, which appear to cover the same ground per provider, so an agent still has to guess the routing.

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

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

There is no guidance on when to use this multi-provider search versus the provider-specific search_linkedin_jobs / search_naukri_jobs siblings, and no mention of prerequisites such as the browser-login tools that appear alongside it. The only implied usage is 'search across two providers,' which the agent must infer.

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

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

No annotations are supplied, so the description carries the full burden of behavioral disclosure. It only notes 'bounded pagination' (already visible as limit maximum 25 in the schema) and says nothing about authentication needs, rate limiting, result ordering, or what a response looks like.

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 single sentence is front-loaded and free of filler, which is good structure. However, brevity here reads as under-specification rather than efficiency given the six undocumented parameters and absence of annotations.

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

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

A six-parameter search tool with zero schema descriptions, no annotations, and no output schema needs the description to explain filtering behavior and pagination mechanics. The current text leaves an agent without enough to invoke it confidently, especially around pageToken usage and recency filtering.

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

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

Schema description coverage is 0% across six parameters, and the description adds no meaning for query, location, remoteMode, postedWithinDays, or pageToken. 'Bounded pagination' gestures at limit/pageToken but supplies no semantics beyond what the schema's min/max constraints already encode.

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

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

The description names a specific verb and resource ('Search public LinkedIn job listings'), which clearly separates it from generic search_jobs and from search_naukri_jobs by source. It stops short of naming those siblings explicitly, so the differentiation is inferable 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?

There is no guidance on when to choose this tool over search_jobs or search_naukri_jobs, nor on prerequisites such as whether a browser session is required. The word 'public' hints at unauthenticated listings but the agent must guess that implication.

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

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

With no annotations, the description carries the full burden, and it does disclose two useful traits: it runs through an already-authenticated browser session (login prerequisite) and pagination is bounded. It omits what happens when the session is unauthenticated, rate limits, and any safety/read-only framing.

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

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

A single front-loaded sentence with no filler; the core resource and session model come first. It is efficient but borders on under-specification for a six-parameter tool.

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

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

Six parameters, no annotations, no output schema, and zero schema description coverage demand far more than one sentence. An agent gets no sense of result shape, paging behavior across pageToken, or how the enum filter (remoteMode) interacts with query.

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 0% with six parameters, so the description should compensate; the only hint is 'bounded pagination', which loosely gestures at limit/pageToken. query, location, remoteMode, and postedWithinDays are left entirely to the bare 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 ('Search Naukri job listings'), and the 'Naukri' qualifier implicitly separates it from search_jobs and search_linkedin_jobs. It stops short of naming those siblings or explaining the distinction 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?

No guidance on when to prefer this over search_jobs or search_linkedin_jobs, no prerequisite conditions stated as instructions, and no exclusions. The agent must infer routing from the provider name alone.

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

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

With no annotations supplied, the description carries the full behavioral burden and does disclose two substantive traits: it launches a headed (visible) browser window, and it never accepts passwords. This security constraint is exactly the kind of context structured fields cannot convey. It stops short of describing the session lifecycle — whether a session is created, how long the window waits, or what state results.

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, zero filler, with the core action stated first and the security constraint second. Every clause earns its place and nothing is buried.

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

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

For a simple one-parameter launcher with no output schema and no annotations, the description covers the action, the execution mode, and a key safety limit. The one real gap is the handoff: nothing tells the agent that human interaction must occur and that a follow-up sibling such as complete_browser_login or get_browser_auth_status is the next step.

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

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

Schema description coverage is 0% for the single enum parameter, so the schema only lists linkedin and naukri without explaining them. The description's phrase "the selected provider login page" adds the meaningful implication that the provider determines which login URL opens, but offers no further semantics for the two values.

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 pairs a specific verb ("Open") with a specific resource ("the selected provider login page") and names the mechanism (headed Playwright window). This distinguishes it from siblings like complete_browser_login and get_browser_auth_status, though it never names those alternatives explicitly.

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

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

"for manual login and MFA" implies the situation that calls for this tool, so usage is inferable. However, it gives no explicit when-to-use versus complete_browser_login, and no statement of prerequisites such as when a session must already exist or what to do after the user logs in.

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