campaignstack

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

Annotations already indicate it is a mutation (readOnlyHint false) and not idempotent (idempotentHint false). The description adds meaningful behavior: it applies the same caps and version snapshots as a manual edit, and it fails if the targeted text changed since the checkup, which implies concurrency sensitivity. It does not contradict annotations.

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

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

Two sentences with no filler. The first sentence states the core action and target, the second gives the precondition and failure handling. Information is front-loaded and 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?

The description covers the action, preconditions, failure behavior, and references the sibling tool for obtaining the checkup. An output schema exists to describe the return value. It lacks nothing essential for correct invocation, though it could mention explicit side effects like creating a version snapshot (already implied by 'version snapshots').

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 have descriptive text. The description itself does not add extra parameter semantics beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the action (accept a pending draft checkup) and the result (applies proposed text to a target, listing the three target types). It distinguishes itself from the sibling get_draft_checkup by requiring prior reading and approval, and from reject_draft_checkup by being the acceptance action.

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

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

Explicitly states when to call: only after the user has read and approved the proposal from campaignstack_get_draft_checkup. It also provides a failure condition and instructs to run a new checkup. It does not name alternative rejection tools, but the when-to-call condition is clear and actionable.

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

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

Annotations already provide idempotentHint=true, readOnlyHint=false, and destructiveHint=false, so the bar for the description is lower. The description adds concrete behavioral context beyond the hints: what idempotency means in practice ('leads already in the list are skipped') and the return shape ('counts added and already-present'). No auth or rate-limit context, but the description meaningfully supplements the annotations.

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

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

Four sentences with each earning its place: purpose, idempotency semantics, parameter structure/returns, and usage routing to siblings. Front-loaded with the core action and zero filler.

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

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

The output schema covers return values, annotations cover the safety profile, and the description covers purpose, idempotent behavior, parameter composition, and lookup strategy for IDs. The only untold details (array max, enum values) are already in the input schema, so this is highly complete for a moderate-complexity 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 carries the burden. It explains the leadRef structure (each needs leadId and leadSource with default 'global') and clarifies the leadListId referent ('existing lead list'). It doesn't explicitly narrate the 100-item cap or enum values, but it compensates well for the schema's lack of descriptions.

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

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

"Add leads to an existing lead list" states a specific verb, resource, and scope. It explicitly differentiates from the sibling campaignstack_create_lead_list by noting that tool makes a new list, and the idempotency note sharpens the behavioral purpose.

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

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

The description explicitly states when to call it ('add named people to a list that already exists') and names the exact alternatives: campaignstack_create_lead_list for new lists, campaignstack_list_lead_lists for finding list IDs, and campaignstack_search_leads for finding lead IDs. Nothing is left to inference.

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

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

Annotations only state read-only false, open-world true, idempotent true, destructive true. The description enriches these with concrete behavioral details: clay's fire-and-forget webhook push with no provider lead id and a dedupe key, email-based creation for other providers, idempotent already_present status, skipIfInWorkspace semantics, zero credit cost, and specific error codes.

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 dense and front-loaded with the core action, but it repeats the external-list-id source twice and packs many clauses into one long paragraph. Every sentence earns its place, though light restructuring and removal of the repeated mention would tighten it further.

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—provider parameterization, idempotency, prerequisites, return statuses, and integration differences—the description covers all invocation-critical context: required prior call, user confirmation, clay vs. email behavior, statuses, error examples, and an explicit alternative for internal lists.

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 83%, but the description goes well beyond the schema by explaining list id provenance, workspaceId key-type behavior (csu_ vs cs_), leadSource default and private CSV scope, clay-specific lead qualification (LinkedIn only), and the meaning of skipIfInWorkspace. It resolves ambiguity the schema leaves open.

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 precise verb+resource: 'Add one lead to an external provider's lead list' and names the three providers. It actively differentiates itself from siblings by stating it does not start outreach (unlike campaignstack_add_lead_to_sequence) and is not for CampaignStack's own lists (use campaignstack_add_leads_to_list).

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?

Explicit when-to-use guidance is present: call only after campaignstack_list_external_lead_lists has supplied a real list id and the user confirms. It also names the alternative for internal lead lists and explains the workflow node equivalence. No ambiguity remains about when this tool is the right choice.

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

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

Even with annotations covering idempotency and side effects, the description adds substantial provider-side behavioral context: lead resolution by email, Apollo auto-creating contacts, emailAccountId requirements, idempotent duplicate statuses, best-effort activation, Instantly handoff sync, zero credit usage, and exact return statuses. This goes well beyond the annotations without contradicting them.

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

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

The description is dense but every sentence adds operational value: prerequisites, provider distinctions, idempotency, activation behavior, sync behavior, cost, and return vocabulary. The most important action and routing guidance are front-loaded, with supporting details following logically.

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

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

Given the tool's complexity, the description covers preconditions, provider-specific parameter needs, idempotency semantics, free usage, and return/error values. An output schema exists, so return-value documentation is not necessary. The agent has everything needed to invoke and interpret the 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 88%, so the baseline is 3, but the description enriches key parameters: it explains provider-specific emailAccountId requirements, activateSequence best-effort semantics, skipIfInWorkspace being Instantly-only, and how campaignId is obtained. It does not add much for leadSource or workspaceId, which are already well described 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?

The description opens with a specific verb and resource: 'Add one lead to an external provider's sequence,' and immediately clarifies provider-parameterized behavior (apollo sequences, instantly campaigns). It explicitly distinguishes itself from campaignstack_trigger_workflow, which is the closest conceptual alternative, so an agent can tell them apart.

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

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

The description gives explicit sequencing guidance: call after campaignstack_list_external_sequences returns a real sequence id, and use campaignstack_list_external_email_accounts for Apollo mailbox ids. It also states the exclusion condition clearly: for a CampaignStack workflow, use campaignstack_trigger_workflow instead.

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?

All annotation hints are false, so the description carries the transparency burden. It discloses validation/normalization, duplicate handling (skipped and reported), per-URL success/error results, and the workspace-wide blocking effect. This is strong behavioral detail for a mutating tool.

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

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

The description is front-loaded with purpose, behavior, and trigger, then provides routing guidance. The final sentence about listing signal agents is somewhat tangential and does not fully earn its place, so it is not a perfect 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?

The definition covers the trigger, prerequisite lookup for exclusionId, duplicate behavior, return behavior, and the inverse operation, while the output schema covers return structure. The only notable gap is the unclear relationship between manual exclusion entries and signal agents.

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?

profileUrls and workspaceId are already documented in the schema, and the description adds meaningful normalization/deduplication context. exclusionId lacks schema-level description, but the description compensates by directing the agent to campaignstack_get_exclusions to find it.

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

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

The first sentence names the exact operation ('Add'), the object ('manual exclusion entry'), and the outcome ('CampaignStack never contacts them'). It also distinguishes itself from the closest sibling by explicitly mentioning the removal counterpart.

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

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

The description gives an explicit trigger: 'Call this when the user names specific people to block workspace-wide.' It also names the inverse tool for removal and tells the agent where to find exclusionId values, making selection and prerequisites clear.

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

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

Annotations already provide readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false. The description adds meaningful behavioral context beyond those: 'Cached 7 days per domain; a repeat call reads the cache' and 'Charges website_intel credits per call.' It also points to campaignstack_estimate_cost for cost pre-checking, which is valuable operational guidance.

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?

Four sentences, each earning its place: what the tool does, when to call it, cache behavior, and cost implications. The trigger context is front-loaded, and the operational caveats are compactly appended without fluff.

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

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

For a one-parameter tool with an output schema present and annotations covering safety and idempotency, the description is complete. It covers the input domain, purpose, trigger conditions, caching, and cost, so an agent has everything needed to select and invoke it correctly.

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

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

The schema only defines `url` with format `uri` and no description, and schema coverage is 0%. The description compensates by clarifying that the URL should be a company's own public website and by referencing 'per domain' caching, which informs how the URL parameter is treated. It could add more explicit URL requirements, but with only one simple parameter this is sufficient.

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

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

The description uses a specific verb and resource: 'Read a company's own public website and extract structured company intelligence.' It enumerates exactly what is extracted (name, description, services, market, industry, team size, tech stack, positioning), making the tool's function unmistakable. The phrase 'company's own public website' and the campaign/draft context help distinguish it from sibling 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?

The description gives an explicit trigger: 'Call this when the user asks to research a company from its site before a campaign or a draft.' This clearly states when to use the tool. It does not explicitly name alternatives or conditions where they would be preferable, so it stops short of a 5.

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

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

Annotations already communicate mutability, non-destructiveness, and idempotency. The description adds valuable context by explaining the state transition from pending to applied, the consequence for prompt construction, and the concrete no-op behavior on active notes. It does not contradict the annotations and provides meaningful behavior beyond their generic hints.

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 three sentences with no wasted words. It front-loads the primary action, then explains when to use it, and ends with the idempotency caveat. Every sentence adds distinct 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?

The description covers what the tool does, when to call it, what effect it has, and how it behaves on already-active notes. The input schema fully documents both parameters, and an output schema exists, so return-value documentation is not required. The tool is simple enough that nothing essential is missing for correct invocation.

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

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

Schema description coverage is 100%, so both parameters are already documented in the input schema. The description reinforces that memoryId comes from campaignstack_list_agent_memories, but it does not add new parameter-level detail beyond what the schema already states. This meets the baseline for full schema coverage without exceeding it.

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

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

The description opens with a specific verb and resource: 'Apply a pending agent memory note now.' It clearly distinguishes the action from the default behavior of waiting for a second independent observation, and it explains the outcome (the note is used in prompts like an asserted note). This makes the tool's purpose immediately identifiable and distinct from sibling memory tools.

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

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

The description explicitly states when to call the tool: after the user reviews a note from campaignstack_list_agent_memories and confirms it is correct. It also frames the tool as an alternative to waiting for a second observation, and notes that applying an already-active note is a no-op. This gives the agent clear conditional guidance for invoking it.

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

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

Annotations only mark the tool as non-read-only, non-idempotent, and non-destructive. The description adds the meaningful state transition from pending_approval to approved and scheduled, plus the scheduling default and alternative path. It stops short of describing broader side effects, but the key behavioral effect is disclosed.

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 tightly scoped sentences: action, when-to-use with a workflow step, parameter choice, and rejection alternative. No filler, and the most important information is front-loaded.

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

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

Given the presence of an output schema and a clear parameter schema, the description covers what an agent needs: the trigger, the pre-call confirmation behavior, scheduling options/defaults, and the sibling to use for rejection. Nothing essential is missing for correct invocation.

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

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

The schema already documents scheduledAt and autoSchedule, so the description's value is in clarifying the 'or' relationship between them and the default ('next slot'). It also reiterates the exact-time vs auto-schedule decision. contentPostId is left to its name/schema, which is sufficient for an identifier.

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 action and resource: 'Approves a pending_approval content post and schedules it for publishing.' It clearly distinguishes from the related reject tool by naming campaignstack_reject_content_post, and the workflow state makes it clear this is not a generic create/schedule action.

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

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

It gives an explicit trigger ('when the user asks to approve a submitted post'), a prerequisite/confirmation step ('after reading its wording back to them'), and a concrete alternative ('Use campaignstack_reject_content_post to send it back to draft instead'). It also explains how to choose scheduling behavior.

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 carry destructiveHint=true and readOnlyHint=false, and the description enriches rather than contradicts them. It explains the mechanism and consequence of the destructive action: drafts advance via the 'approved' edge, and escalated entries get their withheld action RESUMED and re-dispatched/released through the delivery exit. This tells the agent that approving has real irreversible side effects (dispatching messages), which is precisely the behavioral context beyond the annotations.

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

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

Purpose is front-loaded in the first sentence and every subsequent sentence earns its place: draft behavior, escalation behavior, call condition + alternative, and ID sourcing. The only cost is the middle sentence on escalated entries, which is dense with parentheticals ('critic-flagged auto-send, agent escalation') and could be split for readability, but there is zero 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 tool with high complexity (two conditional behaviors, destructive dispatch side effects, a required user-confirmation precondition), the description is complete: both parked-node scenarios are covered, the mutating consequences are spelled out, the alternative tool is routed, and ID sourcing is provided. An output schema exists, so return-value explanation is unnecessary, and the idempotentHint=false annotation covers repeat-call risk.

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 50%; workspaceId's rich semantics live in the schema, and entryId has none. The description compensates by telling the agent where to obtain entryId values ('Use campaignstack_list_pending_reviews to find entry IDs'), which is actionable beyond the schema. The meaning of entryId as the review-entry identifier is clear from context, though it is never explicitly defined — a minor 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?

Opens with a specific verb+resource+qualifier: 'Approve a pending review entry as-is, no wording change.' It then distinguishes itself from campaignstack_edit_and_approve_review by naming the exact condition that selects the sibling, and explains the two distinct approval semantics (draft advancing via the 'approved' edge vs. escalated entries resuming a withheld action). Unambiguous even among 300+ siblings.

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

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

Gives explicit call conditions: 'Call this only after the user has read the draft and says to send it unchanged.' It also states the exclusion ('for different wording, use campaignstack_edit_and_approve_review instead') and provides the ID-lookup path ('Use campaignstack_list_pending_reviews to find entry IDs'). All three routing questions — when, when-not, alternative — are answered directly.

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

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

Annotations already signal destructiveHint=true崗, but the description goes far beyond: it details that the stop is one-way, all workflows and automations pause, unarchiving does NOT restart them, leads stay parked, and no data is deleted. This is exactly the kind of behavioral context annotations cannot capture.

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 long, but for a destructive, irreversible action every sentence earns its place. The critical warning is front-loaded ('WARNING: this STOPS the campaign's work'), followed by consequences, data safety reassurance, and alternatives. No redundant or filler content.

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

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

Given the action's complexity and irreversible side effects, the description covers all essential context: what stops, what does not restart, data preservation, error handling, and sibling routes. An output schema exists, so return-value details are not needed. Nothing an agent needs to call correctly is missing.

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

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

The schema has a single campaignId with no description (0% coverage). The description does not explain campaignId's format, but it does say 'If the campaign is not found, use campaignstack_list_campaigns to find valid IDs,' which indirectly guides the agent on where to obtain the value. This is minimal but sufficient for a self-explanatory ID parameter.

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 starts with 'Archive a campaign' – a specific verb and resource. It immediately distinguishes itself from sibling tools like campaignstack_delete_campaign, campaignstack_unarchive_campaign, and campaignstack_list_campaigns, making its purpose unmistakable even among a huge sibling list.

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 states when to call: 'only when the user names the campaign and confirms they want its outreach stopped, not just hidden.' It also names alternatives for deletion, unarchiving, and finding valid campaign IDs, giving the agent clear routing logic.

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

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

Even though annotations already flag destructiveHint=true, the description adds detailed behavioral context: stops polling, pauses linked workflow, disables watched posts, clears competitor watch linkage, and is recoverable with data retained and visible via includeArchived. This goes well beyond the annotations and paints a complete picture of side effects and reversibility.

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 three efficient sentences: first states the action and effects, second explains when to use it and the recoverability, third names the alternative and the ID-lookup tool. Every sentence earns its place, and the most important information is front-loaded.

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

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

Given one parameter, an output schema, and annotations covering safety, the description is complete. It explains the operational consequences, the difference from pausing/deleting, the recovery behavior, and how to obtain the agent ID. An agent can correctly select and invoke this tool without further research.

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 only one parameter (agentId) and the schema provides no description, so the description must compensate at 0% coverage. It does not explicitly define agentId, but the tool name and opening sentence make the semantic clear, and it provides a concrete way to obtain valid values ('Use campaignstack_list_signal_agents to find agent IDs'). This is sufficient for a single obvious parameter.

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

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

The description opens with a specific verb and resource ('Archive a signal agent') and enumerates exactly what archiving does (stops polling, pauses workflow, disables watched posts, clears competitor watch linkage). It explicitly distinguishes itself from pausing and deleting, leaving no ambiguity about the tool's purpose relative to siblings.

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

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

The description gives an explicit when-to-use condition ('when the user asks to shut a watcher down for good rather than pause it for a while') and names the alternative tool for temporary stops (campaignstack_pause_signal_agent). It also directs the agent to campaignstack_list_signal_agents for finding agent IDs, so the invocation path is fully covered.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds the crucial behavioral detail that the tool does not run the search or return leads itself, which is not explicitly covered by the annotations. It also clarifies the output is a URL to be passed elsewhere, providing useful context beyond the structured 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?

The description is three sentences, front-loaded with the purpose in the first sentence. Each sentence adds distinct value: what it does, when to use it (and what it doesn't do), and the recommended workflow. There is no filler or redundancy.

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

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

Given the tool's simplicity (building a URL) and the presence of an output schema (likely defining the URL return), the description covers the essential aspects: purpose, non-search behavior, and chaining with list_icps and queue_leads. It could mention that all parameters are optional, but that is implied by the schema having no required fields. Overall, it is complete for an agent 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 description coverage is 0%, so the description must compensate. It enumerates all six parameter names (titles, industries, locations, seniorities, company sizes, keywords), which helps map user intent to parameters. However, it does not explain the structure of locations (object with raw, city, region, country) or the array nature of the fields, leaving the agent to rely on the schema for that detail. The description adds some meaning but does not fully 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?

The description clearly states the tool builds a LinkedIn People search URL from ICP criteria, listing the specific criteria fields. It distinguishes itself from search tools by explicitly noting it does not run the search or return leads, setting it apart from siblings like campaignstack_search_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?

It provides explicit usage context: 'Call this when the user wants a LinkedIn search link built from an ICP's criteria.' It also gives a workflow, instructing to use campaignstack_list_icps first and then pass criteria here, and mentions passing results to campaignstack_queue_leads, effectively routing the agent to the correct sequence.

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

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

Annotations already indicate destructiveHint=true, but the description adds depth by explaining that PROCESSING leads are left to finish (due to live runner jobs), that the response reports how many remain, and that only queued work is cancelled—never already-sent messages. This goes beyond the annotation and provides critical behavioral context without contradiction.

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

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

The description is concise yet information-dense. It front-loads the primary action and scope, then provides contextual trigger conditions, exclusionary notes, and a reference to a sibling tool. Every sentence serves a purpose; no filler or repetition.

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

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

For a destructive operation on workflow nodes, the description covers what leads are affected, what happens to PROCESSING leads, how the response reports remaining leads, when to call the tool, and where to obtain node IDs. It also clarifies the irreversible nature of sent messages. Since an output schema exists, return-value details are not required. Nothing essential is missing.

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

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

Schema coverage is 50%: workspaceId has a thorough description, but nodeId has none. The tool description does not directly explain nodeId, though it advises using campaignstack_get_workflow to find node IDs, which gives a hint. This partially compensates but does not fully define the parameter's purpose or format. The description adds little beyond what the schema already provides for workspaceId.

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

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

The description clearly states the action (cancel) and the specific resource (drainable leads at a workflow node), enumerates which lead statuses are affected (WAITING, WAITING_FOR_EVENT, PENDING_REVIEW) and which are not (PROCESSING). It distinguishes itself from siblings by specifying the exact scope of cancellation and the outcome reporting.

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 states when to use this tool: after campaignstack_update_workflow or when a node deletion is rejected with NODE_HAS_ACTIVE_LEADS, to drain the node before retrying the graph change. It also provides a pointer to campaignstack_get_workflow for finding node IDs, and warns against expecting recall of already-sent messages. This is exemplary when-to-use guidance.

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

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

Annotations indicate destructiveHint=true, and the description builds on this by detailing the consequences: 'A comment is public and stays under the owner's name. This reaches a real person. ... goes out as soon as this call succeeds: there is no draft state and nothing to recall.' It also covers non-writable limits (daily/weekly limits, business hours) set by humans, and the overrideOwnLimits semantics. No contradiction; the description enriches beyond annotations.

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

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

The description is long but front-loaded with the core purpose and usage conditions. It packs crucial safety and approval steps into dense prose. It is arguably verbose, with multiple clauses that could be trimmed, but every sentence adds necessary guidance. Efficient given the complexity and risk.

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

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

Given the high complexity and destructive nature, the description covers all critical aspects: when to call, pre-call approvals, public consequence, lack of draft, no bulk form, pacing, and override limits. It also mentions the audit log for overrides. The output schema exists, so return format is covered. No significant gaps for an agent to misuse.

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 low (29%), but the description explains several parameters: 'platform is required (currently "linkedin")', 'leadId' vs 'profileUrl', 'commentText must be the owner's own words', and 'accountId' is optional. However, it does not cover all parameters (e.g., overrideOwnLimits has a detailed schema description but description only references 'overrideOwnLimits' without full semantics, though that's in schema). Baseline 3 is appropriate because the description compensates partially for low coverage.

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

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

The description opens with a specific verb and resource: 'post a comment on a lead's most recent post from a connected LinkedIn account.' It clearly distinguishes the target (most recent post) and platform, and names sibling tools (campaignstack_craft_comment, campaignstack_submit_comment_for_review) for alternatives. This differentiates it from the large sibling set.

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

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

The description explicitly states when to call: 'when the user has approved specific comment wording for a specific lead's post.' It also says when NOT to use it: if comment is not approved, use craft or submit for review instead. It provides clear alternatives for bulk sending (lead list + workflow) and mentions pacing and override limits.

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 sparse annotations by disclosing that the key is validated, the integration is stored, and that success: false still creates an integrationId when validation fails. Also explains refusal behavior over connected-app connections. These are non-obvious side effects an agent needs to know.

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?

Every sentence earns its place: purpose, trigger, validation behavior, failure behavior, connection-channel refusal, and a post-connection next step. Dense but well-organized and front-loaded with the core purpose.

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 definition is complete for an agent to select and call the tool correctly: it covers the trigger, the key input, failure semantics, an alternative path, and follow-up usage. The output schema exists, so return values do not need to be re-explained, and the workspaceId nuances are documented in the input schema.

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

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

The description adds meaning to the undocumented apiKey parameter by identifying it as an Apollo API key. The workspaceId parameter is fully explained in the schema, including the csu_ vs cs_ key distinction and how campaignstack_whoami helps determine which applies. The description does not repeat schema details but covers the one parameter lacking schema-level documentation.

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

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

States a specific action ('Connect an Apollo.io account') and the required input ('API key'). Clearly distinguishes it from sibling connection tools like campaignstack_connect_hubspot and campaignstack_connect_instantly by naming the provider and the exact trigger condition.

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

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

Explicitly says when to call: 'Call this when the user gives you an Apollo API key and asks to connect it.' Also gives an exclusion case (connected-app chat connections) and directs the user to Settings, Integrations instead, while noting an API key can still call this directly. It even suggests the next step with campaignstack_list_external_lead_lists.

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

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

Annotations are minimal (only booleans), so the description carries the full burden. It discloses that the tool validates the token via a 'read ping + write-scope probe,' stores the integration, never echoes the token back, and returns specific error codes with details. It even explains the nuanced missing_scopes behavior around subscription-tier gating and notes the beta status. No contradiction with annotations.

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

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

The description is dense with necessary information and front-loads the core action and token format. Every subsequent sentence adds practical value: validation method, scopes, error codes, edge cases, and restrictions. The flow is logical and avoids redundancy.

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

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

For a complex connection tool, it covers the action, input requirements, validation, error handling, scope prerequisites, channel restrictions, and beta caveat. The output schema exists and the description mentions the success/error shape (success true, errorCode), so an agent has enough to invoke and interpret results.

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 50%: apiKey has only a minLength, while workspaceId has a detailed schema description. The description compensates for apiKey by specifying the required prefix (pat-na1- or pat-eu1-), the scopes needed, and the validation logic. It doesn't need to repeat workspaceId because the schema already covers it comprehensively.

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

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

The description opens with a specific verb and resource: 'Connect a HubSpot portal by providing a Private App access token.' It immediately distinguishes this from sibling connect tools (Apollo, Instantly) by naming HubSpot and the token prefix format. The trigger condition is explicit: 'Call this when the user gives you that token and asks to connect it.'

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?

Provides a clear when-to-call condition and a when-not-to-call restriction: 'Refused over a connected-app (chat) connection: point the user at CampaignStack Settings, Integrations instead; an API key can still call this.' It also lists required and optional scopes, which tells the agent what prerequisites to check before or during the call.

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

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

Annotations already indicate this is a non-read-only mutation (readOnlyHint false) and not idempotent. The description adds valuable nuance: it validates the key, stores the integration, and clarifies that even on failure an integrationId is created. It also discloses the refusal scenario. This exceeds the annotation baseline with useful 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?

Three sentences: the first states the core action, the second gives the trigger and success/failure behavior, the third handles the refusal case. Every sentence serves a purpose, and the most critical information is front-loaded. No fluff.

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

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

The description covers the main action, validation behavior, success/failure semantics, and a specific refusal condition. An output schema exists (not shown) which presumably details the response structure, so the description doesn't need to. It lacks some prerequisites (e.g., where the API key comes from) but these are implied by the tool's purpose. Overall it is sufficient for an agent to call it correctly.

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

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

Schema coverage is 50% (workspaceId has a detailed description, apiKey has none). The tool description mentions 'API key' generically but does not elaborate on apiKey format or constraints. It adds minimal parameter-level meaning beyond what the schema already provides for workspaceId. Since coverage is exactly at the threshold, the baseline of 3 is appropriate.

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

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

The description clearly states the action ('Connect an Instantly.ai account by providing an API key') with a specific verb and resource. It distinguishes from sibling connection tools like connect_apollo and connect_hubspot by naming the specific platform (Instantly.ai). The purpose 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 provides explicit trigger conditions ('Call this when the user gives you that key and asks to connect it') and a clear exclusion ('Refused over a connected-app (chat) connection: point the user at CampaignStack Settings, Integrations instead'). This tells the agent when to use and when not to use the tool, though it doesn't explicitly mention alternatives like other connect tools, the primary usage is well-scoped.

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

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

Annotations already establish readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is fully covered. The description adds valuable context beyond annotations by framing it as a cheap check and clarifying that a zero count signals nothing queued for review, not that nothing is running.

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 earning its place: the first defines the count, the second gives usage and the sibling alternative, and the third prevents a common misinterpretation. The content is front-loaded and free of 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-value details are unnecessary. The description covers purpose, when to use it, the sibling relationship, cost/performance expectations, and zero-value semantics, making it complete for an agent to invoke 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%, and the workspaceId parameter has a thorough explanation of user-key versus workspace-key behavior. The description does not need to repeat parameter details; the schema already carries the full semantic load.

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: it counts drafted touches awaiting approval in the workspace. It also explicitly distinguishes itself from campaignstack_list_pending_reviews, which returns the drafts themselves, making the tool's role unambiguous.

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

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

It says exactly when to call this tool ('when the user asks whether anything needs their attention') and when the sibling list tool is more appropriate ('before campaignstack_list_pending_reviews, which returns the drafts themselves'). This gives clear, actionable routing guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that this is a count-only operation that does not list notifications, which is useful but does not reveal any additional side effects or return behavior. This is adequate given the strong annotations.

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

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

Two sentences, front-loaded with the primary action, and no filler. The 'does not list them' clarification earns its place because it directly prevents a common misuse.

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 idempotent count operation with a rich output schema and well-documented parameter, the description is nearly complete. The only minor gap is not addressing the nearby sibling campaignstack_get_inbox_unread_count, but the tool name and wording already narrow the meaning sufficiently.

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

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

Schema description coverage is 100%, with the workspaceId parameter already well documented: it is required for user keys (csu_), omitted for workspace keys (cs_), and campaignstack_whoami is referenced for determining key type. The description itself adds no parameter-level meaning, 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 opens with a specific verb+resource pair: 'Count unread notifications for a workspace.' It explicitly distinguishes itself from campaignstack_list_notifications by stating it does not list them, so an agent can tell the operations apart without inspecting schemas.

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

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

It gives a clear trigger: 'Call this when the user asks how many there are.' It also provides an exclusion by naming campaignstack_list_notifications for listing. It does not mention the sibling campaignstack_get_inbox_unread_count, which could be a possible alternative, but the guidance is otherwise explicit and sufficient for the primary decision.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this by stating 'it does not post the comment' and 'Show the draft to the user', adding context about the draft-and-approve workflow. No contradiction; the description enriches the behavioral picture without repeating everything.

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

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

Two sentences, no fluff. The first states purpose and non-posting; the second gives usage and alternatives. Front-loaded and efficient.

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 available, the description does not need to explain returns. It covers the core workflow (draft, show user, post separately) and alternatives, which is sufficient for a simple read-only drafting tool. Optional parameters are not mentioned, but they are not essential for basic usage.

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

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

Schema coverage is only 33%, so the description must compensate. It implies leadId refers to the lead and postContent to the post content via 'on a lead's LinkedIn post', but it does not clarify campaignId or instructions, which remain undocumented in both schema and description. Partial compensation, not comprehensive.

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

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

The description clearly states the tool's action: drafting a comment on a lead's LinkedIn post, and explicitly notes it does not post. It differentiates from posting (campaignstack_comment_on_post) and replying (campaignstack_reply_to_comment), making the purpose unmistakable.

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

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

The description gives explicit when-to-use guidance ('Call this when the user asks for a comment on a specific lead's post') and provides the subsequent step (post with campaignstack_comment_on_post) and an alternative for replies (campaignstack_reply_to_comment). This fully routes the agent to the correct tool.

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

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

The description surfaces behavior the annotations do not: it reads the stored conversation, accepts unsynced lead messages via conversationMessages, detects lead intent, and does not send the message. No annotation contradicts the description, and readOnlyHint=false is consistent with a drafting tool that still performs server-side generation.

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 short sentences, front-loaded with the core action and constraints, then workflow and sibling alternation. Each sentence adds a distinct fact and there is no repetition of schema fields.

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

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

Covers trigger, non-sending side effect, conversation source, intent detection, follow-up action, and sibling disambiguation. An output schema exists, so the return format does not need to be explained in the description.

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

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

The description adds meaning for conversationMessages by explaining that the stored thread is combined with newly passed lead messages, but it leaves several parameters (leadId, accountId, instructions, campaignId) to inference. With schema coverage at 50%, this is adequate but not comprehensive.

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

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

Opens with a specific verb and resource ('Draft a contextual follow-up message'), immediately states the non-sending boundary, and explicitly routes first messages to campaignstack_craft_message. This gives an agent a clear model of what the tool is for 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?

'Call this when the user asks for a reply or a follow-up nudge in an existing LinkedIn thread' is an explicit trigger. It also names the send step (campaignstack_send_message) and the alternative for first messages (campaignstack_craft_message), which is textbook when-to-use guidance.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, so the description only needs to add context beyond that. It does, by clarifying that the tool only drafts and never sends, and by stating that the draft should be shown for approval. This adds meaningful behavioral context without contradicting the annotations.

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

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

The description is compact, front-loaded with the core purpose, and every sentence adds operational value. It efficiently covers the main action, the trigger condition, the required approval step, the sending alternatives, and the exclusion of follow-ups without any 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?

Given the tool's moderate complexity and the presence of an output schema, the description covers the essential workflow: when to call, what to do with the result, and how to route to sending tools. It falls short only in fully explaining the optional parameters, but the core context for selecting and invoking the tool 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 only 33%, and the description does not compensate for the missing parameter details. It vaguely maps leadId to 'specific lead' and campaignId to 'full campaign context', but it does not explain the roles of instructions, messageTemplate, or campaignId more concretely. With several undocumented optional parameters, an agent would have to guess at their intended semantics.

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

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

The description clearly states the specific action: drafting a personalized LinkedIn first message using campaign context, and explicitly notes it does not send anything. It distinguishes itself from related tools like campaignstack_craft_followup, campaignstack_send_message, and campaignstack_send_inmail, making the tool's unique role unmistakable.

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 explicit when-to-use guidance: 'Call this when the user asks for a first-touch message to a specific lead.' It also names the follow-up action, specifies which send tool to use based on connection status, and explicitly excludes follow-up crafting by directing to campaignstack_craft_followup. This is exemplary routing guidance.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral context beyond that: it produces a draft only, does not send the connection request, enforces a 300-character limit, and instructs the agent to show the result to the user before passing it onward. No contradiction with annotations.

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

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

Three sentences, all information-dense: the core action and constraint, the non-sending behavior, the exact call scenario, the follow-up action, and the sibling alternative. Nothing is wasted or repeated from the schema or 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?

The description provides the full workflow, including showing the note and passing it to campaignstack_send_connection_request, and an output schema exists to document the return value. The main gap is the lack of guidance on the required leadId parameter and optional campaignId/instructions, though the connection-note context gives reasonable inference.

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

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

Schema description coverage is only 40%, and the description does not compensate for the undocumented parameters. leadId is the sole required parameter and has no description in the schema or the description, and campaignId and instructions are also unexplained. The description clarifies the tool's output flow but not the meaning of its own inputs.

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

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

The description names a specific verb ('Draft'), a specific resource ('LinkedIn connection note'), and a concrete constraint ('max 300 characters'). It also explicitly says the tool 'does not send the connection request', and differentiates itself from the sibling campaignstack_craft_message for first messages after connecting.

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 explicit: call it when the user asks for a connection request note, show it to the user, then pass it as the note argument to campaignstack_send_connection_request. It also gives a clear alternative with campaignstack_craft_message for first messages after connecting, leaving no ambiguity about when to choose 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?

Annotations already signal this is a write operation that is not destructive or idempotent. The description adds useful behavioral context beyond those flags: the campaign is created empty, it should be followed by other create calls, and 'Nothing reaches anyone as a result of this call.' This meaningfully clarifies the side-effect profile.

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?

Four concise sentences, each earning its place: what the tool does, when to call it, what it does not do, and what the next steps are. The most important scoping and safety information is front-loaded.

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

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

Given the moderate complexity, the schema coverage for workspaceId, and the presence of an output schema, the description is complete. It covers when to call, what the call creates, what it deliberately does not create, follow-up calls, and the absence of outreach side effects.

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 low (25%), with only workspaceId described. The description compensates for the required parameters by adding the crucial rule that the title and goal must come from the user and must not be invented by the agent. The remaining optional parameters are self-explanatory or already covered by 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?

Describes a specific action ('Create a campaign') and defines the entity as the container that workflows, ICPs, and lead lists hang off. It explicitly differentiates itself from related create tools by stating the campaign is created with no ICP, workflow, or 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?

States exactly when to call it: when the user says to start a new campaign and has supplied the title and goal. It also tells the agent what not to do ('not yours to invent') and names the follow-up tools (campaignstack_create_icp and campaignstack_create_workflow), which is explicit routing guidance.

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

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

Discloses important behavior beyond the annotations: first run snapshots the employee set, weekly re-reads and diffs against it, emits a scored signal, is idempotent, and is capped per workspace. The 'idempotent' claim is consistent with the idempotentHint annotation, and no contradiction with readOnlyHint=false exists.

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

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

Three dense sentences with no filler. The primary purpose is front-loaded, followed by mechanics, usage trigger, and sibling differentiation. Every sentence adds actionable information.

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

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

For a create-watch tool with two simple parameters, an output schema, and annotations covering idempotence and safety, the description provides all necessary decision-making context: when to call, what it does over time, the rosters-vs-individual distinction, and the sibling alternative. Nothing critical is missing.

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

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

Schema coverage is 50%, but the workspaceId parameter has a thorough description in the schema explaining key types and scoping. The description makes clear that companyId refers to the company whose roster is watched, compensating for the missing companyId description. The tool's semantics around new hires supply the remaining parameter context.

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: 'Watch a company for NEW employees' and details the exact mechanism (snapshot, weekly diff, emits company_employee_joined signal). Explicitly distinguishes itself from campaignstack_create_signal_watch for individual 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 a direct trigger condition: 'Call this when the user asks to be alerted about new hires at a company.' It also names the alternative tool and the condition that selects it: 'use campaignstack_create_signal_watch for an individual lead.'

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 and destructiveHint=false, so the write nature is already known. The description adds valuable behavioral detail beyond annotations: 'Automatically deduplicates by normalized LinkedIn URL within the workspace.' This clarifies the tool's idempotency behavior (though idempotentHint=false, dedup implies no duplicates are created). It also clarifies the roster scope, which is a useful behavioral note. No contradictions with annotations.

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

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

Four sentences, each earning its place: the core purpose, a deduplication note, a pointer to a listing sibling, and a distinction from a related roster. No redundancy or fluff. Front-loaded with the main action.

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

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

The description provides enough for an agent to use it correctly: it states what it creates, the entity types, deduplication behavior, when to call it, and how it differs from a similar tool. Since an output schema exists, it doesn't need to explain return values. It could mention exclusions (e.g., when not to use it for search watches), but the trigger condition is clear. Overall, it is fairly complete for a create operation.

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

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

Schema description coverage is only 40% (accountIds and workspaceId have descriptions; name, entityType, profileUrl do not). The description partially compensates: it explains that the tool monitors a LinkedIn company page or influencer profile (relating to profileUrl and entityType), and deduplication by normalized LinkedIn URL gives meaning to profileUrl. However, it does not explain the 'name' parameter or the relationship between workspaceId and key types beyond what the schema already states. Given the low coverage, the description adds some value but does not fully fill the gaps.

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

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

The description clearly states the tool's purpose: 'Creates a new competitor watch to monitor a LinkedIn company page or influencer profile.' It specifies the entity types (company or influencer) and explicitly differentiates from a sibling tool: 'This is a different roster from the comparison-page list: campaignstack_search_console_set_competitor manages that one.' This distinguishes it from at least one relevant alternative.

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

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

The description gives a clear trigger: 'Call this when the user names a company page or influencer to track ongoing.' It also directs to a related listing tool: 'Use campaignstack_list_competitor_watches to see existing watches.' It differentiates from the comparison-page roster by naming the sibling that handles that. However, it does not explicitly contrast with other watch-creation siblings (e.g., search watch, employee watch), leaving some ambiguity for similar-sounding tools.

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

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

Annotations already indicate a mutating, non-idempotent, non-destructive operation. The description adds meaningful behavior beyond that: the agent is created paused, at most one is allowed per account across all workspaces, and it routes new connections into an auto-generated workflow. This is useful operational context, though it does not address permissions or failure behavior if a second agent is attempted.

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 no filler: main behavior is front-loaded, followed by the uniqueness/paused constraints, then explicit routing to the preferred sibling. Every sentence carries decision-relevant information.

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

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

For a two-parameter tool with an output schema and rich annotations, the description covers the essential context: what the agent does, its one-per-account constraint, its initial paused state, and when to use a higher-level alternative. Nothing critical is missing for selecting and invoking 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?

Schema description coverage is only 50%, so the description must compensate. It clarifies that linkedinAccountId is the LinkedIn account being watched, and workspaceId is already well documented in the schema. However, it does not explain how to obtain linkedinAccountId or any expected format beyond the parameter name, leaving some ambiguity.

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

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

The description opens with a specific verb and resource: 'Create a connection-watch signal agent for a LinkedIn account', then clarifies the mechanism (routes new connections into a welcome workflow). It also distinguishes itself from campaignstack_set_account_watcher and the broader create_signal_agent family, so an agent can identify exactly what this tool does versus its siblings.

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

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

The description gives explicit selection guidance: 'Call this only when you need the lower-level create-then-resume path directly; prefer campaignstack_set_account_watcher, which does both steps and also covers the message and own-posts watchers.' It also states the created agent is paused, implying a resume step may be needed. This is model routing guidance, not just a restatement of purpose.

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 useful behavioral context beyond annotations: it creates a draft, returns a post ID, infers postType from media, and does not immediately publish. But the claim that it does not schedule is inconsistent with the schema's scheduling parameters, creating confusion about the tool's actual behavior. No contradiction with annotations exists.

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

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

The description is reasonably concise and front-loaded with the core purpose. Each sentence contributes useful guidance, though the no-scheduling point is repeated twice and could be trimmed without losing meaning.

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

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

The description covers when to use the tool, what it returns, and where to read the created post, and it points to relevant sibling tools. But the scheduling contradiction, plus missing guidance on how to source authorAccountId and workspaceId (beyond the schema's own description), leaves the tool not fully self-contained for correct invocation.

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

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

Schema description coverage is only 33%, so the description needs to compensate. It does add meaning for postType ('inferred from media when omitted') and enumerates valid tag values, which is valuable. However, it leaves core parameters like authorAccountId, body, and mediaIds mostly unexplained, though their names and the LinkedIn context provide some 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?

Clearly states the action ('Creates a draft content post'), the resource ('for a connected LinkedIn account'), and the key constraint that nothing publishes yet. It is immediately distinguishable from siblings like campaignstack_schedule_content_post and campaignstack_submit_content_for_approval, and the return value is mentioned.

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 tells the agent when to call this tool ('draft, write, or queue up a LinkedIn post') and names alternatives for scheduling or approval. However, the statement 'It does not publish or schedule the post' is contradicted by the input schema's scheduledAt and autoSchedule parameters, which do schedule after creation, so the guidance is slightly misleading.

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

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

The annotations already indicate this is not read-only, not idempotent, and not destructive, and the description does not contradict them. The description adds workflow context but does not explain side effects, return behavior, or whether an ICP can be duplicated, so it provides only moderate behavioral value beyond the annotations.

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

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

The description is three sentences, with the core purpose and fields stated first and workflow guidance kept tight. Every sentence adds useful information and none is wasted.

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

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

Given the nested schema and eight parameters, the description is mostly sufficient: it states when to use the tool, how to get the required campaignId, and what to do next. The main gap is the thin coverage of parameter semantics, especially for siteFacts and fitStatement, though the schema partially compensates for those.

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

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

Schema description coverage is only 25%, so the description carries responsibility for explaining parameters. It names several fields like titles, industries, seniorities, company sizes, and keywords, but adds little semantic detail beyond their labels and does not explain nuanced parameters like siteFacts or fitStatement.

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: create a new ICP for a campaign, and lists the main targeting fields. This clearly distinguishes it from creation tools for other entities like campaignstack_create_campaign or campaignstack_create_persona.

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

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

The description explicitly says when to call this tool, names the follow-up tool campaignstack_trigger_icp_scoring, and tells the agent to use campaignstack_list_campaigns for valid campaignId values. This leaves no ambiguity about 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?

Annotations already indicate this is not read-only and not destructive, and the description reinforces the creation behavior. It adds the 'static' vs 'dynamic' distinction and notes that leadRefs is optional, but it does not disclose possible duplicate-name behavior, error conditions, or side effects. There is no contradiction with the annotations.

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

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

Three sentences, each earning its place: the first defines the operation and optional payload, the second gives the primary use case and sibling alternative, and the third points to prerequisite lookup tools. No filler or repetition.

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

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

For a create tool with a small schema and an output schema, the description is complete: it covers what the tool does, when to use it, how it differs from the closest sibling, and how to resolve required IDs. Nothing essential for a correct call is missing.

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

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

The schema has 0% description coverage, so the description carries the parameter-documentation burden. It explains the leadRefs structure ('leadSource default global, leadId'), notes leadRefs is optional, and tells the agent how to source campaignId and leadId values. It does not explicitly mention the 'private' leadSource option, but the schema covers that.

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

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

The description states a specific action ('Create a new static lead list in a campaign') and names the resource and optional payload. It clearly distinguishes this from the query-based sibling, campaignstack_create_query_lead_list, so an agent can tell them apart.

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 explicitly says to use this tool for a named, fixed group of leads and points to the rule-based alternative for a list that stays current against a rule. It also tells the agent to use campaignstack_list_campaigns and campaignstack_search_leads to find valid campaign and lead IDs.

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 are all false and therefore convey little safety or behavior profile, so the description carries the burden. It adds meaningful behavioral context by clarifying that the tool's effect is limited to shaping generated copy rather than filtering or scoring leads. It could go further by describing what happens on validation failure or output shape, but the schema and output schema cover much of that.

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 three short sentences with no filler. It front-loads the core purpose, then supplies the trigger, the boundary against lead scoring/filtering, and the ID lookup helper. Every sentence earns its place.

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

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

Given the 8-parameter schema, the existing output schema, and detailed per-field descriptions in the schema, the description does not need to enumerate every field. It covers the essential context: what the tool creates, when to invoke it, what it does not do, and how to obtain the required campaign ID. It could be slightly stronger by naming the scoring/filtering alternative tool explicitly, but it is otherwise 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 63%, and the schema already documents goals, objections, painPoints, fitStatement, and objectionResponses in detail. The description adds conceptual meaning by grouping the persona around "pain points, goals, and objections," and it compensates for the undocumented campaignId parameter by explicitly naming campaignstack_list_campaigns as the source for campaign IDs.

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

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

The description opens with a specific verb and resource: "Create a persona in a campaign," and immediately defines what a persona is: "a buyer archetype with pain points, goals, and objections." It also draws a clear boundary against related tools by stating "It does not filter or score leads, only shapes generated copy," which keeps it distinct from ICP or scoring tools.

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

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

The description gives an explicit trigger condition: "Call this when the user describes a buyer type to add." It also provides an exclusion criterion ("does not filter or score leads") and directs the agent to a supporting sibling tool for the required campaign ID: "Use campaignstack_list_campaigns for campaign IDs." This is actionable and sufficient for tool selection.

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

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

With annotations already marking this as non-read-only and non-destructive, the description adds genuinely useful behavioral context: 'order controls sequencing' and 'It does not build any workflow'. These clarify side effects and non-effects beyond what the schema or annotations expose.

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

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

The description is compact and front-loaded: the first sentence states the purpose, followed by a clear when-to-use call, a sibling distinction, and a practical prerequisite. No wasted words.

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

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

The description covers the tool's role and sequencing well, and output schema existence reduces the need to explain return values. However, with low schema parameter coverage and no explanation of core parameters like objectives, campaignId, or description, an agent must infer too much when constructing a correct call.

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

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

Schema description coverage is only 17%, so the description must compensate for undocumented parameters. It only clarifies the 'order' parameter ('order controls sequencing'). The required parameters campaignId, name, description, and objectives receive no semantic explanation, leaving significant ambiguity.

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

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

The description clearly states the verb and resource ('Create a campaign phase'), adds the clarifying parenthetical 'roadmap milestone', and explicitly differentiates from campaignstack_create_workflow. An agent can understand exactly what this tool creates and how it differs from a similar sibling.

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

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

It gives an explicit trigger ('Call this when the user describes a new stage to add'), names the alternative tool for workflow creation, and instructs the agent to use campaignstack_list_phases first to pick an order. This is strong, actionable guidance.

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

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

The description adds meaningful behavioral context beyond the annotations: it clarifies that members resolve dynamically from include/exclude lists and filter rules on a recurring cadence, not a fixed set. This complements the readOnlyHint=false annotation by explaining how the mutation behaves, though it doesn't disclose side effects beyond that.

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, no filler. The core definition is front-loaded, the usage criterion is next, and the reference to sibling tools is last. Every sentence earns its place.

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

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

Given the nested query object and multiple required parameters, the description covers the main decision points and ID sourcing. The presence of an output schema covers return-value expectations. It is slightly incomplete because the filter rule structure inside the query object is not described, but the overall guidance is enough for an agent to proceed in most cases.

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

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

With 0% schema description coverage, the description must compensate for parameter meaning. It usefully clarifies campaignId via 'use campaignstack_list_campaigns to find campaign IDs' and include/exclude lead list IDs, and mentions filter rules. However, it does not explain the structure or semantics of the 'filter' array or how 'logic' interacts with it, leaving a notable gap for a nested query object.

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

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

The description clearly states a specific verb and resource ('Create a dynamic query-type lead list') and immediately distinguishes it from the sibling 'campaignstack_create_lead_list', which is for fixed named people. This removes any ambiguity about what the tool does.

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 explicitly tells when to use this tool ('Call this for a list that stays current against a rule') and names the alternative for the opposite case ('For a fixed group of named people, use campaignstack_create_lead_list instead'). It also references sibling tools for resolving required IDs, making selection guidance complete.

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

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

The description discloses several important behaviors beyond the annotations: polling every ~6 hours, past-24h relevance-sorted search, feeding authors into the campaign, the one-active-watch-per-topic rule, and the disabled/ownership-transfer behavior when a duplicate watch is created. This is exactly the kind of non-obvious runtime context an agent needs.

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

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

The description is dense but each sentence earns its place: purpose, mechanism, trigger, deduplication rule, ownership transfer, and prerequisite lookup tools. No filler or repetition.

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

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

Given the tool's complexity, the description covers the mechanism, frequency, side effects, duplicate handling, and prerequisite discovery. An agent has enough information to decide when to call it and what to expect, especially with the output schema also 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?

The input schema already documents topicId and accountIds well. The description reinforces the topic semantics and account scoping, but campaignId has no schema description and the tool description only refers to it implicitly through 'campaign.' It adds some context but does not fully compensate for the campaignId 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 opens with a specific verb and resource: 'Set up a LinkedIn search watch that automatically discovers new leads for a campaign.' It then explains exactly what the watch does (monitors a topic keyword, reads post authors, feeds them into the campaign), making it easy to distinguish from other watch-creation tools like competitor or signal watches.

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

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

It gives an explicit trigger: 'Call this when the user asks to start monitoring a topic on LinkedIn for a campaign.' It also names supporting tools for checking existing watches and campaign topics. It does not explicitly contrast with sibling watch tools, but the context is clear enough for selection.

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

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

Annotations already convey that this is a non-read-only, non-idempotent, non-destructive operation, so the description does not need to restate those. It adds useful behavioral context by disclosing that calling it also auto-generates a template workflow and lead list, and by clarifying that accountIds observe while actAccountIds act on signals.

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 dense but well organized: action and side effects first, then routing guidance, then target shapes, then account semantics. Every sentence earns its place and no content is repeated from the schema or annotations.

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

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

For a tool with 11 parameters, nested target objects, and several sibling tools, the description covers the essential selection logic, target construction, and account-role distinction. The main gap is that the required responseMode parameter is not explained in the description, though its enum values are self-descriptive and the output schema handles return-value documentation.

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

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

With schema description coverage at only 9%, the description compensates substantially by documenting the target object's three shapes (profile/company, group, post) and the distinct roles of accountIds and actAccountIds. It does not explain responseMode or the optional configuration parameters, but the core non-obvious parameters are meaningfully described.

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

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

The description states a specific action ('Create a new signal agent'), the monitored resource types (LinkedIn profile, company feed, group, or post), and the expected side effects (auto-generates template workflow and lead list). It also differentiates itself from explicitly named siblings like campaignstack_set_account_watcher and campaignstack_create_competitor_watch.

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

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

The description provides crisp selection criteria: use this tool when the target is not a competitor and not account maintenance, names the exact alternative tools for those cases, and explains when the competitor-watch tool should be used instead. This is explicit routing guidance rather than leaving the agent to infer 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?

Annotations already signal non-read-only, idempotent, and non-destructive behavior. The description adds meaningful context: daily profile refresh, in-app + email alerts, and per-workspace caps. This goes beyond the structured annotations without contradicting them.

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

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

Four short, front-loaded sentences, each earning its place: behavior, usage trigger, idempotency/cap, and sibling distinction. No filler or redundant elaboration.

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

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

The description covers what the tool does, when to use it, behavioral details, constraints, and the main alternative. An output schema exists, so return-value details are not needed. The only notable gap is the unexplained leadSource parameter, but overall the agent has enough context to invoke it correctly in common cases.

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

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

Schema description coverage is only 33%; only workspaceId has a description. The description does not clarify the meaning or selection logic for leadSource (global vs private), and it adds no parameter guidance beyond the schema. The semantic weight falls on the agent to infer leadSource behavior.

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

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

The description clearly states the action ('Watch a lead for profile signal changes'), the monitored fields (title, company, seniority, headline, location), and explicitly distinguishes this from the company-employee-watch sibling. An agent can immediately understand the tool's unique purpose.

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

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

It gives an explicit trigger: 'Call this when the user names a lead and asks to be told about their next job or title change.' It also names the alternative for new hires at a company, providing a clear decision boundary.

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

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

Annotations are all false (no safety hints, no readable/idempotent/destructive flags), so the description carries the burden. It discloses the success return value ({ workflowId, nodeCount }), the optional sourceConfig with its default (campaign_pool source, icpScoreMin 50), and the tool's scope ('authors campaign-pool sourcing only'). It could add behavior around validation failures or exact side effects, but for a create operation the disclosed information is above average.

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 dense but every sentence earns its place: purpose, prerequisites, return value, default behavior, and explicit routing to alternatives. It is slightly long, with some run-on sentences, but it is front-loaded with the core purpose and the usage guidance is well organized. Minor redundancy exists around 'campaign-pool sourcing only' stated twice, but overall it is efficient.

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 (nested graph, sourceConfig, multiple ways to create workflows), the description is remarkably complete. It covers what the tool does, when to use it, how to get schema info, what it returns, the default source behavior, and exactly which sibling tools handle the lead-list cases. With a rich input schema and high coverage, nothing critical is missing for an agent to decide and invoke 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 high (80%), so the baseline is 3. The description adds extra meaning beyond the schema: it explains the sourceConfig default value, its provider-only constraint, and the need to use campaignstack_get_workflow_node_types for configHint shapes and graph format. It also clarifies that the graph parameter uses nodeType/label/config and edges with sourceIndex/targetIndex, reinforcing the schema without repeating it.

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

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

The description opens with a specific verb and resource ('Create a new workflow from a graph you author') and immediately distinguishes it from template- or watcher-generated workflows. It names concrete node types and edge concepts, and the sibling reference to other creation tools clarifies exactly what this tool is and isn't for.

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 states when to call ('when the user wants a custom automation graph built node by node, beyond what a template or watcher would generate'), and gives precise exclusions with named alternatives: watchers for lead-list-fed workflows, and the lead-list-plus-trigger pattern for self-built lists. Also names campaignstack_get_workflow_node_types as a required prerequisite discovery step.

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 mark it non-read-only and non-idempotent; the description adds crucial operational traits: async build tracked by generationId, one build at a time, free-account limit of two workspaces, and a workspace key cannot create another workspace. No contradiction with annotations.

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

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

Long but tight: every sentence adds a decision rule or constraint, and the core purpose is front-loaded before the detailed edge cases. The structure moves from primary behavior to parameter conditions to auth and limits without waste.

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 create-and-build operation with no required parameters, the description covers all input variants, auth prerequisites, async return behavior, follow-up tools, and account limits. An agent has what it needs to invoke and monitor the 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?

Even though the schema already covers each parameter, the description adds meaningful semantics: goal must be first-person and becomes the campaign goal verbatim; name defaults to the company name; websiteUrl alone suffices; profileUrl is read through the user's own connected LinkedIn account. These details materially improve correct invocation.

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

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

States a specific action and object ('Create a workspace and build it') and enumerates the concrete outputs (company context, playbook, first campaign, ICP, workflow, lead pool). This makes it clearly distinguishable from nearby create_* siblings like create_campaign or create_workflow.

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?

Provides explicit when-to-use conditions: supply websiteUrl, profileUrl, or both; pass goal only when the user gave it in first-person; omit name unless the user chose one. It also clarifies that a profile requires a connected LinkedIn account while a website alone does not, and names follow-up tools for linking/connecting an account and tracking setup progress.

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 indicate it's not read-only and not destructive. The description adds crucial behavioral detail: 'Accept applies every change in one transaction through the same caps, version snapshot and user-authored reconciliation as a manual edit; it fails when a targeted text changed... Reject applies nothing.' This discloses atomicity, version snapshot handling, and a failure condition, going beyond the annotations. However, it does not mention potential side effects like logging or approval workflows, but the key behaviors are covered.

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

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

The description is concise and front-loaded with the core purpose. It contains no fluff; each sentence provides essential information—purpose, precondition, transactional behavior, failure mode, and simple reject case. The structure is logical and easy to parse in a few seconds.

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 moderately complex with a precondition, two distinct outcomes, and a failure scenario. The description covers both accept and reject behaviors, explains the transaction and reconciliation mechanism, and specifies when to re-propose. With an output schema present, return values are covered. Nothing essential for an agent to call this 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 67% (proposalId and workspaceId have descriptions, decision does not). The tool description fills the gap by explaining 'accept' and 'reject' semantics, effectively documenting the decision parameter. The workspaceId description is thorough. The description itself does not add parameter details, but it compensates for the missing decision description.

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

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

The description clearly states the action: 'Accept or reject the pending playbook proposal.' It specifies the resource (playbook proposal) and the two possible decisions. It also distinguishes from sibling tools like campaignstack_propose_playbook_change and campaignstack_get_playbook_proposal by referencing the prerequisite tool and the decision-making context.

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 states when to call: 'Call this only after the user has read the proposed text from campaignstack_get_playbook_proposal and said yes or no.' It also provides failure handling: 'it fails when a targeted text changed since the proposal was made, in which case propose again.' This gives clear preconditions and fallback actions, distinguishing when this tool should be used and when not.

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

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

The description discloses the irreversibility and the immediate effects on active and pending notes, which goes beyond the destructiveHint annotation. It explains that active notes stop being used in future prompts and pending notes lose their observation count. This is valuable 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?

Two sentences, front-loaded with the action and key constraint (cannot be undone). The structure is efficient with no filler.

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

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

The description covers the essential behavior, prerequisites (user review), and consequences. With an output schema present and annotations covering destructive nature, nothing critical is missing. Could mention permissions, but that's not always necessary.

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 parameters are already documented. The description adds minimal extra value—it reiterates that memoryId comes from the list tool, but doesn't expand on workspaceId beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the action (delete), the resource (agent memory note), and specifies the scope (pending or active). It differentiates from other delete tools by focusing on agent memories and references the listing tool, making it easy for an agent to understand what it does.

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 an explicit usage trigger: after the user reviews a note from campaignstack_list_agent_memories and requests removal. This tells the agent when to call it. It doesn't explicitly mention when not to use it, but the trigger is specific enough.

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

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

Even though annotations already set destructiveHint=true, the description adds crucial context: irreversibility, the full list of cascade-deleted data, the confirmation requirement, and the not-found behavior. This goes well beyond the structured annotation and prepares the agent for the real consequences of invoking the tool.

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

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

The description is dense but every sentence earns its place: the destructive warning and cascade scope are front-loaded, the irreversibility is stated upfront, and the usage guardrails and error fallback follow naturally. The long list of cascaded data is justified because it conveys the true blast radius of the operation.

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 tool with one parameter, an output schema, and clear annotations, the description is complete. It covers the operation, the full side effects, the required user consent, the alternative tool, and the recovery/fallback path when the ID is invalid. Nothing essential is missing for an agent to decide whether and how to invoke it.

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

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

The schema only declares campaignId as a required string with no description, so schema coverage is 0%. The description compensates by clarifying that the agent should confirm the campaign name and obtain valid IDs via campaignstack_list_campaigns, which indirectly explains the meaning and provenance of campaignId. It does not explicitly describe the ID format, but the guidance is sufficient for a single-parameter tool.

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

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

The description opens with 'PERMANENTLY delete a campaign' and enumerates the full cascade of associated data, naming a specific verb and resource. It is clearly distinguishable from sibling campaignstack_archive_campaign, which is explicitly called out as the non-destructive alternative.

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

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

The description gives explicit when-to-use and when-not-to-use guidance: only when the user explicitly says to delete the campaign and its data, not merely to stop it. It also names the alternative (campaignstack_archive_campaign), instructs the agent to confirm the campaign name with the user, and provides a fallback to campaignstack_list_campaigns when the campaign is not found.

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 destructiveHint=true annotation, the description adds meaningful behavioral context: the action is irreversible and it also disables associated automations. This helps an agent understand consequences before calling. No contradiction exists between the description and annotations.

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

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

Three concise sentences deliver the action, the irreversible side effect, and the when-to-use guidance in exactly the right order. Every sentence earns its place with no filler or repetition.

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

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

For a simple one-parameter destructive tool with annotations and an output schema, the description covers what is deleted, the downstream effect on automations, irreversibility, and the correct alternative. Nothing essential is missing.

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

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

Schema description coverage is 0%, and the description does not explicitly explain the watchId parameter. However, with only one required parameter whose name is self-explanatory and the description's clear 'Deletes a competitor watch,' the intended meaning is reasonably inferable, so the gap is minor rather than severe.

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

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

The description begins with a specific verb and clear resource: 'Deletes a competitor watch' and adds the key side effect 'disables its associated automations.' It clearly distinguishes this destructive action from the pause variant, leaving no ambiguity about what the tool does.

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 explicitly names campaignstack_pause_competitor_watch as the alternative for temporary monitoring and states the exact condition for choosing delete: 'the user wants the watch gone for good, not just stopped for a while.' This is strong, unambiguous routing guidance.

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

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

Annotations already declare destructiveHint=true, but the description adds meaningful context by stating the deletion cannot be undone and is limited to draft or failed posts, leaving scheduled and published posts untouched. It stops short of describing permissions or error behavior, but the additional behavioral detail is useful beyond the annotations.

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

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

Three short sentences with the main action and consequence front-loaded, followed by the trigger and the exclusion with an alternative. Every sentence serves a purpose and there is no filler.

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

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

For a single-parameter destructive tool with annotations and an output schema, the description covers what is deleted, irreversibility, when to call it, and what to do instead for scheduled or published posts. Nothing needed to safely invoke the tool is missing.

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

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

There is one parameter, contentPostId, with zero schema-level description. The description does not explicitly define the parameter, but 'draft or failed content post' and 'remove a post they no longer want' give enough context to infer that contentPostId should identify the target post. This is partial compensation for the low coverage, not full documentation.

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 precise verb-object pair: 'Deletes a draft or failed content post.' It identifies the resource, the allowed states, and the irreversibility of the action. The explicit boundary ('does not touch a scheduled or published post') clearly differentiates it from related content-post 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?

It gives an explicit trigger: 'Call this when the user asks to remove a post they no longer want.' It also states when not to use it and names the prerequisite sibling tool, campaignstack_unschedule_content_post, for scheduled or published posts. This fully routes an agent between delete and unschedule.

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

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

Annotations already mark destructiveHint=true, but the description adds materially: deletion is irreversible ('cannot be undone'), it removes every computed score, and campaigns relying on the ICP 'stop matching anyone.' This provides concrete cascading consequences beyond the annotation flags.

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?

Four sentences, each earning its place: the core destructive action, the irreversible consequence, the safe invocation guardrail, and the alternatives. The most critical information is front-loaded, and there is no redundancy or padding.

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, single-parameter tool with an output schema and strong annotations, this description is complete. It covers the action, the full blast radius, irreversibility, confirmation behavior, parameter sourcing, and the edit alternative. Nothing essential for correct invocation 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 0%, so the description must compensate. It directs the agent to campaignstack_list_icps to find ICP IDs and signals that the user may refer to the ICP by name, requiring an ID lookup. It does not elaborate on ID format, but the single non-empty string parameter leaves little ambiguity.

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 precise verb and resource: 'Delete an ICP and every score computed against it,' clearly distinguishing this from the sibling update and list tools. It also explicitly contrasts with campaignstack_update_icp, making the tool's exclusive role unmistakable.

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

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

It gives an explicit invocation condition: 'Call this only when the user names the ICP and says to delete it,' plus a mandatory confirmation step ('name it back to them first'). It also names alternatives: campaignstack_update_icp for edits and campaignstack_list_icps for finding IDs.

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

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

Annotations already flag destructiveHint=true, and the description goes further by saying 'Permanently delete' and 'no restore tool exists'. It also warns to confirm the ID first, which is useful behavioral context for an irreversible mutation. No contradiction with annotations.

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

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

Three short sentences with no filler: the core action, irreversibility, usage trigger, alternative, and prerequisite all fit compactly. The most important behavioral warning is front-loaded.

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

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

For a simple destructive tool with a single parameter and an output schema, the description covers purpose, irreversibility, when to avoid it, and ID verification. Nothing material is missing for an agent to call it correctly.

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

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

Schema coverage is 0%, but the single required parameter is self-describing as personaId and the description directly addresses it: 'Use campaignstack_list_personas to confirm the ID first.' This tells the agent how to obtain a valid value, though it does not specify ID format or provenance in detail. That is enough compensation for a one-parameter tool.

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

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

The description opens with a specific action and object: 'Permanently delete a persona'. It also distinguishes this from editing by naming campaignstack_update_persona, and clarifies there is no restore tool, so an agent can tell this delete operation apart from siblings.

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

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

It states the exact trigger condition: 'Call this only when the user explicitly asks to remove one'. It excludes the edit case and points to campaignstack_update_persona, and instructs using campaignstack_list_personas to confirm the ID first. This is explicit when/when-not plus actionable prerequisite.

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

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

Annotations already mark destructiveHint=true, but the description goes further by stating 'no restore tool exists' and leading with 'Permanently delete'. This adds the crucial irreversibility context beyond the annotation's binary destructive flag. It also gives a safe procedure (confirm ID first) that improves the agent's awareness of side effects.

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

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

Two sentences, no filler, and the most critical information (permanence/irreversibility) is front-loaded. Each clause adds value: the action, the warning, the alternative, and the prerequisite. This is concise without being under-specified.

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

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

For a single-parameter destructive action with an output schema present, this description covers everything an agent needs: what it does, when to use it, how to get the parameter, and the irreversible consequence. No gaps remain that would cause an incorrect invocation.

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

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

With 0% schema description coverage, the description must compensate for the parameter phaseId. It does that by saying to use campaignstack_list_phases to confirm the ID first – telling the agent where to obtain a valid value. While it doesn't describe format or constraints beyond the schema's type/minLength, it gives practical sourcing guidance that the schema 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 opens with 'Permanently delete a campaign phase' – a specific verb and resource with the important qualifier 'permanently'. It explicitly distinguishes itself from campaignstack_update_phase ('not to reorder it'), so an agent can immediately tell which tool is which among the many phase-related siblings.

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

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

It gives an explicit trigger condition ('only when the user asks to remove one'), a clear exclusion ('not to reorder it'), names the alternative tool for that case, and even provides a prerequisite step (confirm the ID via campaignstack_list_phases). This is textbook usage guidance – nothing left to inference.

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

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

The description states the operation archives (non-destructive) but the annotations declare destructiveHint: true. This is a direct contradiction. The description does clarify the behavior, but the mismatch with structured data is serious and confusing.

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

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

Two sentences, front-loaded with deprecation status and the correct alternative. Every word earns its place, and the structure is ideal for a deprecated alias.

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 deprecated alias, the description fully covers what it does, what to use instead, and the semantic difference. The output schema exists, so return format is not needed. Complete for its purpose.

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 provides no parameter information. While agentId is trivial and self-explanatory, the low coverage requires the description to compensate, which it does not. At most a minimal score for an obvious parameter.

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 explicitly states this is a deprecated name for campaignstack_archive_signal_agent and clarifies that it archives rather than deletes. This makes the tool's actual purpose unambiguous and distinguishes it from the delete-named sibling.

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

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

It explicitly says 'Use campaignstack_archive_signal_agent', providing clear direction to the correct sibling. It also explains the semantic difference (archives vs deletes), so an agent knows when to prefer the alternative.

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

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

Beyond the destructiveHint annotation, the description details irreversibility and enumerates the exact cascading deletions: workflow nodes, edges, lead-list source providers, node lead-list entries, per-lead workflow contexts, and webhook tokens. This gives the agent essential risk information not present in the structured annotations.

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

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

Each sentence earns its place: the destructive action is front-loaded, usage guardrails come next, the cascading impact is enumerated compactly, and the alternative is named last. The length is justified by the irreversibility and breadth of affected data.

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 single-parameter tool, the description covers preconditions, how to find the parameter value, what gets destroyed, and the non-destructive alternative. Since an output schema exists, omitting return-value details is acceptable, and nothing essential is missing.

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

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

The schema only defines workflowId as a required string with no description, so schema coverage is 0%. The description compensates by directing the agent to campaignstack_list_workflows to obtain the correct workflow ID, which gives practical parameter sourcing even though it does not restate the obvious semantics of workflowId.

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 'Permanently delete a workflow and all associated data,' giving a specific verb, resource, and scope. It clearly distinguishes this from merely disabling a workflow by naming the alternative campaignstack_update_workflow_status.

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

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

It gives explicit preconditions: call only after the user has named the workflow and explicitly confirmed deletion. It also tells the agent to use campaignstack_list_workflows to find workflow IDs and points to campaignstack_update_workflow_status as the non-destructive alternative.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds that the tool 'only explains the decision' and lists the diagnostic components, reinforcing a non-mutating behavior without contradicting annotations. It doesn't go deeper into authentication or rate limits, but the annotations cover the safety profile well.

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 longer than necessary but every sentence adds value: purpose, parameters, report contents, usage trigger, exclusions, and ID-finding guidance. It is front-loaded with the diagnostic purpose and uses a structured list for the report contents. Only minor redundancy exists (e.g., 'only explains the decision' overlaps with read-only 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?

With an output schema present, the description doesn't need to explain return values, yet it still summarizes the report content. It covers when to use, what it does not do, and how to source valid IDs. The main gap is that the necessity of leadId/profileUrl relative to workflowId is implicit rather than explicit, which could cause an agent to call it with only workflowId and get a degraded result.

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

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

Schema coverage is 0%, so the description must compensate. It explains that workflowId is required and that either a leadId or a profileUrl (LinkedIn URL) is accepted. It also guides the agent to find valid IDs. However, it doesn't clarify whether at least one of leadId/profileUrl is mandatory beyond the required workflowId, leaving slight ambiguity.

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: 'Diagnose why a specific lead was or wasn't sourced into a workflow.' It enumerates the exact diagnostic report contents and explicitly names sibling tools that change filters, making the purpose distinct from campaignstack_update_filter_exclusion_rules and campaignstack_toggle_exclusion.

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?

Provides an explicit trigger: 'Call this when the user asks why a lead never showed up in a workflow.' It also explains what the tool does not do ('It only explains the decision'), names alternatives for changing filters, and instructs the agent to use campaignstack_list_workflows or campaignstack_search_leads to find valid IDs.

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