campaignstack

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

Annotations only declare non-read-only, non-idempotent, non-destructive. The description adds substantial behavioral depth: the edit goes 'through the same caps and version snapshots as a manual edit' (versioning semantics), and it discloses a concrete failure condition — staleness when the targeted text changed since the checkup ran — plus a remediation path. 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, each earning its place: action with effect, behavioral equivalence to manual edits, then failure mode plus remediation. The core verb and resource are front-loaded and the target enumeration is parenthesized so it doesn't interrupt the main clause. Zero 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 2-parameter action tool with no output schema, the description covers what is applied, where it is applied, how it behaves relative to manual edits, when it fails, and what to do next. The only gap: it never states what a successful call returns or how the agent confirms the text was applied, which matters because there is no output schema to fall back on.

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

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

Schema coverage is 100%, so both parameters are already documented. The description adds one genuinely useful semantic beyond the schema: the checkupId becomes invalid if the target text changed after the checkup ran, which tells the agent that a freshly fetched id is required. Modest but real added meaning.

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 (accept) and resource (pending draft checkup), then defines the concrete effect: applies the proposed text to its target, enumerating the possible targets (intent detail, playbook section, or offer context). This clearly separates it from the sibling group get/run/reject_draft_checkup without needing to open any schema.

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

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

Provides clear trigger context: there must be a pending draft checkup, and it explicitly routes the stale-checkup case to 'run a new checkup in that case.' However, it never names the reject_draft_checkup alternative or states when declining is the right call, so the when-not-to-use guidance is incomplete.

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 the safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false), and the description adds genuine value beyond them: it details the idempotent skip behavior ('leads already in the list are skipped') and discloses the return payload (counts of newly added and already-present leads). This is useful behavioral context a schema cannot convey, and 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?

Five sentences, each earning its place: purpose, idempotency behavior, parameter requirements, return value, and prerequisite tool routing. The core purpose is front-loaded in the first sentence and there is no filler or redundancy.

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

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

Strong completeness for a two-parameter mutation: the safety profile is covered by annotations, the return format is disclosed because no output schema exists, and prerequisite lookup tools are explicitly named despite a very large sibling set. The main remaining gap is the meaning of the leadSource enum values ('global' vs 'private') and error behavior for non-existent 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 description coverage is 0%, so the description carries the burden for parameter meaning. It does restate the leadRef structure and the leadSource default ('global'), and it routes the agent to tools that produce valid IDs, which is helpful. However, it does not explain the semantic difference between 'global' and 'private' lead sources or what leadListId refers to beyond its name, leaving a real 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?

States a specific verb ('Add') and resource ('leads to an existing lead list'), making the operation unambiguous. The qualifier 'existing' implicitly distinguishes it from list-creation tools like campaignstack_create_lead_list. However, it does not explicitly differentiate from similar add-to-target siblings such as campaignstack_add_lead_to_external_list or campaignstack_queue_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 clear workflow context by naming the exact prerequisite tools: campaignstack_list_lead_lists for lead list IDs and campaignstack_search_leads for lead IDs. This tells an agent how to assemble a valid call. It stops short of stating when NOT to use this tool or naming an alternative operation, so exclusions are 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 provides extensive behavioral detail beyond annotations such as clay's fire-and-forget push semantics, the absence of a provider lead id, the campaignstack_dedupe_key behavior, idempotent duplicate handling via already_present, skipIfInWorkspace semantics, and free credit usage. It also enumerates return statuses and example errors, and does not contradict 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 long, but it carries a high density of necessary edge-case and routing information that would otherwise be unavailable to the agent. It is front-loaded with the primary action and provider set, though it could benefit from structural separation such as bullets.

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

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

With no output schema, the description compensates by explicitly listing return statuses and error examples. It also covers provider differences, qualification rules, idempotence, free usage, and cross-tool references, making it complete enough for an agent to select and invoke the tool correctly.

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

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

Schema coverage is already high at 83%, but the description adds meaning beyond the schema by explaining provider-specific behavior for clay, clarifying that listId is a provider-side id from campaignstack_list_external_lead_lists, and detailing how skipIfInWorkspace behaves. The exact source or type of leadId is implied rather than explicitly clarified, so it does not receive a 5.

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 what the tool does: 'Add one lead to an external provider's lead list' with explicit providers instantly, hubspot, or clay. It also distinguishes itself from related tools by name, including campaignstack_add_lead_to_sequence and 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?

The description explicitly tells when to use this tool versus alternatives: it notes that unlike campaignstack_add_lead_to_sequence, adding to an external list does not start outreach, and it directs users to campaignstack_add_leads_to_list for CampaignStack's own lead lists. It also tells the agent to use campaignstack_list_external_lead_lists to obtain list 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 (idempotentHint=true, readOnlyHint=false, destructiveHint=false) are consistent with the description, which goes well beyond them: Apollo auto-creates missing contacts, duplicate adds return already_present as an idempotent success, activateSequence is best-effort ('a sequence that is already active is left as is'), and Instantly handoffs trigger automatic reply/bounce/unsubscribe state sync. The 'Free: no CampaignStack credits' note is the kind of operational context that saves an agent from making wrong assumptions.

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 disciplined: every sentence carries a distinct fact (resolution behavior, idempotency, best-effort activation, state sync, cost, return statuses, ID lookup routing). No filler or name-restating tautology. It runs long, but the length is justified by the provider-parameterized complexity and the absence of an output schema, which makes the status enumeration load-bearing.

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

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

For an 8-parameter, provider-parameterized mutation with no output schema, this is complete: it fully enumerates possible return statuses including example error codes with their causes (INTEGRATION_NOT_CONNECTED, INTEGRATION_KEY_INSUFFICIENT_SCOPE for non-master Apollo keys, LEAD_NOT_FOUND), explains provider differences, prerequisites, idempotency semantics, and cost implications. An agent has everything needed to decide, invoke, and interpret the result 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 schema carries most parameter meaning. The description adds genuine value beyond it: it explains that leadId is resolved by email on the provider side (the only undocumented parameter), clarifies that campaignId is the provider-side sequence id, and reinforces that emailAccountId is a sending mailbox required only by Apollo. This compensates for the one uncovered parameter without redundant restatement.

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,' immediately clarified as provider-parameterized ('apollo sequences, instantly campaigns'). This cleanly separates it from siblings like campaignstack_add_lead_to_external_list (lists vs. sequences) and campaignstack_sync_lead_to_hubspot (CRM sync vs. sequence enrollment) without needing to inspect either schema.

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

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

The description gives strong usage context: provider-specific prerequisites (Apollo requires emailAccountId, activateSequence is Apollo-only, skipIfInWorkspace is Instantly-only) and explicit pointers to sibling tools for ID lookups ('Use campaignstack_list_external_sequences for sequence ids and campaignstack_list_external_email_accounts for Apollo mailbox ids'). It does not explicitly state when NOT to use the tool versus the add-to-list siblings, relying on naming, which keeps it from 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?

The description discloses that URLs are validated and normalized, that duplicates within the same exclusion are skipped and reported, and that per-URL results are returned. This goes well beyond the sparse annotations (readOnlyHint=false, destructiveHint=false) by describing actual runtime behavior and response shape. It does not claim any irreversible effects, consistent 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, all informative: action, validation/dedupe behavior, return format, and dependency lookups. No filler or repeated schema information; it front-loads the purpose and keeps related references at the end.

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 mutating tool with no output schema and minimal annotations, the description covers the key behaviors an agent needs: what is added, how input is handled, what the response reports, and where to find required identifiers. It could add a note on workspaceId behavior or invalid-exclusionId errors, but the schema and existing pointers largely cover those gaps.

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

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

Schema coverage is 67%, and the description compensates: it clarifies that profileUrls are validated/normalized and duplicates are handled, and it tells the agent where to obtain exclusionId (get_exclusions). The workspaceId behavior ('required for user keys; workspace keys are bound') is left to the schema, but the description adds enough extra meaning to the required parameters.

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

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

The description opens with a precise action: 'Add LinkedIn profile URLs to a manual exclusion entry.' It names the resource (manual exclusion entry) and object (URLs), and distinguishes itself from get_exclusions, list_manual_exclusion_urls, and remove_manual_exclusion_url by its add semantics. This is enough for an agent to select it for append operations.

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

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

It explicitly directs the agent to campaignstack_get_exclusions for finding exclusionId values and campaignstack_list_signal_agents for signal agents, covering prerequisite lookups. However, it does not explicitly contrast this with sibling tools like campaignstack_remove_manual_exclusion_url or campaignstack_list_manual_exclusion_urls, so the 'when not to use' guidance is only implied by the name rather than stated.

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

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

The annotations already establish readOnly, idempotent, and non-destructive behavior. The description adds useful behavioral context beyond those hints, specifically that results are cached for 7 days per domain, which is important for agents deciding whether to call again or expect fresh data. It does not mention potential external network latency or failure modes, but the annotations cover the safety 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?

The description is three sentences, each earning its place: what the tool returns, the caching behavior, and when to use it. It is front-loaded with the core purpose and avoids any filler or repetition of schema details.

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

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

For a simple one-parameter read-only tool, the description is complete: it specifies inputs implicitly, enumerates the outputs, discloses caching behavior, and states the intended use case. The annotations cover safety and idempotence, so no critical behavioral information 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 only implicitly refers to the URL parameter by saying 'Analyze a website' and mentioning 'per domain.' The single parameter is self-explanatory with format: uri, so the gap is less severe than with multiple parameters, but the description still does not clarify URL conventions such as whether a root domain is required or whether subpages are acceptable.

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 ('Analyze a website') and the resource, then enumerates the specific output fields such as company name, services, target market, tech stack, and positioning. This makes it distinct from sibling tools like get_company or enrich_company_info, which operate on stored or enriched records rather than extracting fresh intelligence from a website URL.

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

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

The description provides clear context: 'Use this to gather context about a lead's company before creating campaigns.' It does not explicitly mention when not to use it or name alternatives, so it falls just short of a 5, but the stated use case gives an agent enough guidance for typical 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?

The annotations already establish the operation is not read-only, not destructive, and idempotent. The description adds useful behavioral context: it transitions the post out of pending_approval, auto-schedules when no exact time is given, and reports the resolved scheduledAt in the response. It does not discuss failure modes or edge cases, but the safety profile is already covered by 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 focused sentences: the main behavior, the scheduling options, and the sibling alternative. No filler, no repetition of schema details, and the most important information is front-loaded.

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

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

For a tool with one required parameter and no nested objects, the description is complete enough for an agent to call it correctly. It explains both scheduling modes and mentions the key response field. The absence of an output schema means more detail about the full response would be helpful, but the essential behavior is well covered.

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%, and the description compensates well for the scheduledAt and autoSchedule parameters by explaining the exact-time path, the auto-scheduling path, and the 'omit scheduledAt' default. contentPostId gets no detailed semantics, but its role as the target post is clear from the surrounding text and schema.

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

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

The description states a specific action ('approves'), a specific resource ('content post'), and a clear precondition ('pending_approval'), plus its scheduling effect. It also names the directly related sibling campaignstack_reject_content_post, distinguishing approval from rejection unambiguously.

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

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

It clearly defines when to use the tool: when a content post is pending approval and the user wants to approve and schedule it. It also explicitly points to campaignstack_reject_content_post as the alternative for sending it back to draft. It does not mention exclusions like already-approved posts, so it falls just 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?

Description discloses that approval triggers edge traversal for drafts and resumes withheld actions for escalated entries, including re-dispatching runner actions or releasing the draft. This adds meaningful behavioral context beyond the raw annotations, which only state readOnly=false and idempotent=false.

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 all contribute: the first states the purpose, the next two detail the two modes, and the last gives a concrete discovery pointer. No filler or 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 the two complex execution paths fully, so an agent can predict side effects before calling. The lack of output-schema details is acceptable here since no output schema is provided and the action semantics are thoroughly specified.

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 compensates by telling the agent to use campaignstack_list_pending_reviews to find entryId, giving the key parameter actionable meaning. workspaceId remains generic, but its name is self-explanatory and common across workspace-scoped tools.

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

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

States the verb 'Approve' and the resource 'pending review entry' with enough specificity to separate it from sibling approval tools for ad creatives and content posts. It also explains what approval means in two distinct workflow contexts, which goes beyond a generic one-liner.

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 identifies the two situations where the tool applies (draft at a review node, escalated entry at the acting node) and directs the agent to campaignstack_list_pending_reviews for entry IDs. It does not explicitly mention alternatives such as reject_review or retry_review, so exclusions are left to the agent, but the contexts are 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?

Beyond the annotations (destructiveHint=true, idempotentHint=true), the description discloses the one-way stop, paused workflows, disabled automations, the fact that unarchiving does not restart anything, and the preservation of leads in flight and campaign history. It also explicitly warns to confirm with the user, which is critical for a destructive operation.

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

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

The description is front-loaded with the core action and immediately states the most important warning. Every sentence adds necessary operational or safety information, and there is no filler or redundancy; the explicit guidance about related tools 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?

For a destructive, one-way action with a single parameter and no output schema, the description covers all essential context: the irreversible nature, what gets paused/disables, what happens to leads and history, how to reverse, and how to locate campaigns. Nothing an agent needs to call this safely 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 and only provides campaignId as a required string, so the description carries the burden. It adds practical context by telling the agent to use campaignstack_list_campaigns to find valid IDs if the campaign is not found, which helps disambiguate the parameter and offers recovery guidance.

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

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

The description opens with a specific verb and resource, 'Archive a campaign,' and then clarifies what archiving does. It also differentiates from related operations by explicitly naming unarchive and noting that no data is deleted, distinguishing it from deletion tools in the 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 provides explicit usage guidance: confirm with the user before calling, use campaignstack_unarchive_campaign to reverse, use campaignstack_list_campaigns with includeArchived to find archived campaigns, and use campaignstack_list_campaigns to find valid IDs when a campaign is not found. This clearly directs the agent to the right alternatives and gives preconditions.

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 readOnly, idempotent, and non-destructive behavior, and the description adds that this returns a 'ready-to-use LinkedIn search URL' rather than executing a search. The build-and-return framing makes the pure, side-effect-free nature clear 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?

Three short sentences front-load the purpose, then describe inputs, output, and surrounding workflow. Every sentence adds useful information 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 pure URL-builder with safe annotations, the description explains the key pipeline context: where criteria come from, what is returned, and how to use the result. It is missing minor details like whether criteria are AND/OR combined and that all parameters are optional, but the schema and sibling workflow cover much of that.

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

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

Schema description coverage is 0%, so the description carries the parameter documentation burden. It does list all six ICP field groups ('titles, industries, locations, seniorities, company sizes, and keywords'), but it adds no formatting or semantics beyond the schema's property names, such as the structure of the location objects or constraints.

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

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

The description opens with a specific verb and resource: 'Build a LinkedIn People search URL from ICP criteria', then enumerates the input fields and the output. This clearly separates it from search, import, and creation siblings like campaignstack_search_leads and campaignstack_queue_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 gives an explicit workflow: call campaignstack_list_icps to fetch ICP criteria, pass them here, then feed the URL to campaignstack_queue_leads. It does not explicitly state when not to use it or name alternatives, 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?

The description adds meaningful behavior beyond the annotations: it explains which lead states get cancelled, which are left to finish, and that the response reports how many remain. With destructiveHint and idempotentHint already present, this nuanced partial-cancellation behavior is exactly the extra 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?

Three dense sentences front-load the effect, then provide the exception, then give the trigger context and lookup pointer. There is no filler or repetition of schema/annotation information.

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

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

For a destructive operation with no output schema, the description covers what will be cancelled, what won't, what the response indicates, when to use it, and how to find required IDs. Nothing critical is missing for an agent to decide to call it and interpret the result.

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

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

Schema description coverage is 0%, so the description must compensate. It indirectly explains nodeId by describing workflow nodes and telling the agent to use campaignstack_get_workflow to find node IDs, but it never mentions workspaceId or how to obtain it, leaving one of the two required parameters only inferable from its name.

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: 'Cancel the drainable leads at a workflow node', then defines which entries are affected (WAITING, WAITING_FOR_EVENT, PENDING_REVIEW) and which are not (PROCESSING). This distinguishes the tool from workflow-update/delete and node-inspection siblings, so an agent can identify when this tool applies.

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: use it to drain a node when campaignstack_update_workflow or a node deletion fails with NODE_HAS_ACTIVE_LEADS, then retry the graph change. It also states what to expect for PROCESSING leads and points to campaignstack_get_workflow for finding node IDs, which is concrete 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?

Beyond the annotations, it reveals that posting is subject to budget and business-hours gates, that bypassing removes all LinkedIn safety limits, and that this can lead to account flagging or restriction. It also explains automatic account selection, which is unobservable from 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 action is front-loaded, and every sentence adds necessary operational or safety context. The warning is repeated for emphasis but earns its place given the risk of disabling LinkedIn protections.

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 required context, parameter variants, conditional account selection, and safety implications—all essential for a side-effecting tool with no schema and no output schema. Nothing needed to invoke it correctly is missing.

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

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

Despite an empty input schema, the description documents platform, target (profileUrl or leadId), commentText, accountId, and bypass behavior, including where to source accountId and commentText. The sole-source parameter documentation fully compensates for schema absence.

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

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

The opening sentence names a specific action and resource: commenting on a lead's most recent post with provided text. Combined with 'platform is required (currently LinkedIn)', it clearly distinguishes this from siblings like like_post, reply_to_comment, and send_message.

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

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

The description gives clear conditional usage: which target forms are accepted, when accountId must be provided, and that commentText can come from campaignstack_craft_comment. It lacks explicit exclusions or when-not-to-use guidance against sibling tools, but the context is unambiguous.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=true), the description discloses important behavioral nuances: the key is validated against the Apollo API, the integration is stored, and a failed validation still creates an integrationId. This partial-failure behavior is exactly the kind of side-effect detail an agent needs and is not visible in the annotations or schema. It could have mentioned idempotency explicitly, but the disclosed state transitions provide solid transparency.

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 four sentences with no filler. Each sentence earns its place: connect purpose, validation behavior, success/failure return semantics, and a helpful next-step pointer. The most important information is front-loaded, and the structure is easy for an agent to scan.

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 simple enough that the description covers the key operational details: what it does, how validation behaves, what success/failure looks like, and the next recommended action. It does not explicitly explain what happens on reconnection or how idempotency manifests, but the annotations already signal idempotent behavior. The missing pieces are minor given the schema covers the workspaceId nuance.

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 50%, with apiKey lacking a description and workspaceId already documented in the schema. The description adds meaning for apiKey by explaining it is the Apollo API key used for validation, but it does not elaborate further on key types or acquisition. It adds no new information about workspaceId, which the schema already covers. This partially compensates for the coverage gap, but not fully.

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 an Apollo.io account by providing an API key.' It clearly identifies the tool as the Apollo-specific connection action, distinguishing it from sibling tools like campaignstack_connect_hubspot and campaignstack_connect_instantly. It also states the validation and storage behavior, leaving no ambiguity about what the tool accomplishes.

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

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

The description gives clear context for when to use this tool: when connecting an Apollo.io account via API key. It also provides a direct follow-up action ('Use campaignstack_list_apollo_sources after connecting'), which helps the agent sequence next steps. It does not explicitly name when not to use it or contrast it with other connect_* tools, but the domain-specific purpose is clear enough for correct 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?

The description far exceeds what annotations provide. It discloses validation behavior, integration storage, a complete errorCode taxonomy, the subtle subscription-tier gating gotcha that mimics missing_scopes, the promise that the token is never echoed back, and beta-status limitations. These behavioral traits are genuinely additive and help the agent reason about outcomes; 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?

The description is long, but every sentence earns its place: purpose, validation behavior, prerequisites, success contract, error taxonomy, a subtle failure-mode explanation, security reassurance, and caveat. It is front-loaded with the core action before diving into edge cases, and there is no redundant 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?

Despite having no output schema, the description covers the success return (success: true), all failure errorCodes, the trickiest failure nuance (tier gating masquerading as missing scopes), and beta-status expectations. For a connection tool with complex external failure modes, nothing critical an agent needs to invoke it correctly is missing.

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

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

With only 50% schema coverage, the description compensates meaningfully: it documents the apiKey token format (pat-na1-…/pat-eu1-…) and ties parameter semantics to behavioral consequences (scope requirements, validation, error codes). The workspaceId parameter is already described in the schema, so the description need not repeat 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 states a specific verb (connect) plus resource (HubSpot portal) and the precise mechanism (Private App access token). It separates itself from sibling connection tools like campaignstack_connect_apollo and campaignstack_connect_instantly by binding the action to HubSpot and describing the validation workflow, not just restating the name.

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 conveys clear usage context: it states the token format expected (pat-na1-… or pat-eu1-…), the mandatory scopes required, and what validation will occur (read ping + write-scope probe). It does not explicitly name alternatives or exclusion conditions, but the prerequisites effectively tell an agent whether it is in a position to call the tool successfully.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=true), the description discloses validation behavior, persistence of the integration, and the important partial-failure semantics where integrationId is still created even on failed validation. This adds meaningful runtime context not evident from annotations alone.

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

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

The description is tightly structured in three sentences: what the tool does, what it validates and stores, and what the return semantic is. No sentence is wasted, and the most important action verb 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 two-parameter integration connector with no output schema, the description sufficiently explains the inputs, the validation flow, the persistence side effect, and the success/failure return semantics. The surprising behavior of creating an integrationId even on failure is explicitly called out, which is exactly the kind of context an agent needs.

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

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

The description adds functional meaning for apiKey by explaining that it is validated against the Instantly API, going beyond the schema's type/minLength constraints. The workspaceId parameter is not described in the description, but the schema already provides a useful explanation for it, so the combined coverage is adequate.

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 ('Connect an Instantly.ai account'), names the exact resource type, and clarifies the mechanism (API key validation and storage). It also distinguishes itself from sibling connector tools like campaignstack_connect_apollo and campaignstack_connect_hubspot through the explicit 'Instantly.ai' reference.

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

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

The description clearly implies this tool is for connecting an Instantly.ai account using an API key, which provides a clear context for when to use it versus other connector tools. However, it does not explicitly name alternatives or state when not to use this tool, so it falls short of fully 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful behavioral context beyond those annotations by specifying exactly what is counted ('entries awaiting human approval') and what the return value is (a total number). This is especially valuable because there is no output schema.

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

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

The description is one efficient sentence with no filler. It front-loads the action ('Count'), states the resource, and immediately clarifies the return value. Every clause earns its place.

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

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

For a simple count operation with one parameter, the description is complete: it states the scope, the subject, and the return format. Annotations cover the safety profile, so no further behavioral caveats are necessary. The absence of an output schema is adequately compensated by explicitly stating the return value.

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

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

Schema description coverage is 0%, so the description must compensate for the workspaceId parameter. The phrase 'in a workspace' does add some meaning by indicating that workspaceId scopes the count, but it does not explain where to obtain the ID or any additional constraints beyond the schema's minLength. The single self-explanatory parameter keeps this adequate but not strong.

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 ('Count'), names a precise resource ('pending workflow review actions'), and scopes it to a workspace. It also states the exact return behavior ('Returns the total number of entries awaiting human approval'), which clearly distinguishes it from sibling tools like list_pending_reviews.

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

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

The intended use is implied by the verb and return value: call this when you need a count of pending review actions rather than a detailed list. However, there is no explicit mention of the natural alternative (campaignstack_list_pending_reviews) or any when-not-to-use guidance, so the agent must infer the distinction.

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

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

Annotations already cover read-only/idempotent/non-destructive behavior. The description adds return semantics ('Returns the total number') and the intended use, which is valuable since there is no output schema. It does not discuss what happens when workspaceId is omitted or invalid, but for a simple count operation this is a minor gap.

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

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

Two tight sentences: purpose, return value/use case, and routing to the sibling tool. No filler; the essential information is front-loaded.

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

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

For a simple count operation with strong annotations and a single self-explanatory parameter, the description covers the return value and points to the list alternative. The only notable omission is workspaceId behavior (optionality/default), which prevents a perfect score.

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 explain the workspaceId parameter beyond repeating that the count is 'for a workspace.' It does not clarify whether workspaceId is required, what format it should take, or what happens if it is omitted. The property name is self-explanatory, but the description adds no parameter-level meaning.

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

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

The description names a specific verb and resource ('Count unread notifications for a workspace') and states the exact return value ('total number of unread notifications'). It also explicitly contrasts with campaignstack_list_notifications, so the agent can distinguish count from list operations.

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

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

It gives a clear use case ('useful for badge counts') and an explicit alternative: when you need to see the actual notifications, use campaignstack_list_notifications. This tells the agent when to choose this tool and when to route elsewhere.

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 that the operation is read-only and non-destructive, so the bar is lower. The description adds useful behavioral context by noting that the comment is AI-generated and aimed at building rapport. It does not disclose, however, whether the tool returns the comment text for approval or directly submits it, which is material for an agent.

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 the core purpose stated first. Every sentence contributes: what it generates, what inputs it uses, and when to use it. No filler or redundant restatement of the tool name.

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 purpose, input context, and usage timing, and annotations cover safety. However, there is no output schema, and the description does not state the return value (e.g., a crafted comment string) or clarify that this tool only generates the comment and does not post it. Given the empty schema, an agent could be unsure how to call it or what to do with the result.

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

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

There are zero parameters in the schema, so the baseline is 4. The description adds conceptual meaning by naming the inputs the agent should make available: post content, lead context, and campaign context. It cannot score higher because the actual schema has no parameter fields, leaving how to pass these inputs unspecified.

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: 'Generate a relevant comment for a LinkedIn post.' It clearly communicates the tool's function and implies it is a drafting/generation tool rather than a posting action. It does not explicitly name or differentiate from sibling tools like campaignstack_comment_on_post or campaignstack_reply_to_comment, so it stops short of a 5.

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

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

The description gives a clear context for use: 'engaging with a lead's LinkedIn posts before or after connecting.' This tells the agent when the tool is appropriate. It lacks explicit when-not-to-use guidance or mentions of alternatives, such as using comment_on_post when the intent is to publish the comment.

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 non-readOnly/non-idempotent/non-destructive, which is relatively uninformative. The description adds real behavioral detail: it compares agent messages with stored history, stores new messages as a side effect, and runs AI crafting plus lead-intent detection. This goes well beyond what the annotations convey.

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

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

Four tightly packed sentences with no filler; the main purpose and primary differentiator are front-loaded, and the sibling routing is stated at the end. Every sentence adds 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 no-parameter tool with no output schema, it covers the workflow, side effects, intent detection, and where to use it. The one gap is that the return value (crafted reply and/or intent classification) is implied rather than explicitly stated.

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

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

The input schema has zero parameters and 100% schema coverage, so the baseline is 4. The description explains the data flow ('agent-provided messages', 'stored history') despite no schema fields, though it leaves slightly unclear how messages are supplied to a tool with an empty input 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 ('Generate a contextual follow-up message') and explains the underlying process. It explicitly differentiates from campaignstack_craft_message for first-contact messages, so an agent can tell them apart immediately.

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 clear routing guidance: 'Use for any message where prior conversation exists' and explicitly directs first messages to campaignstack_craft_message. This leaves no ambiguity about when this tool is appropriate.

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 this as readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by revealing that it fetches lead profile, campaign goal, ICP, and persona data from Convex and then uses AI to craft the message. It could go further by explicitly stating that it only returns a draft and does not send the message, but this is not a contradiction and the readOnly hint mitigates the gap.

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

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

Two sentences, no filler. The main purpose is front-loaded, followed immediately by usage constraints and the alternative tool. Every sentence earns its place.

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

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

For a zero-parameter generation tool, this is largely complete: it describes the inputs it fetches, the output it produces, and when it should not be used. The only minor gaps are that it does not explicitly state how the target lead/campaign is resolved (since there are no parameters) and does not state the return format, but the readOnlyHint and 'craft a message' wording make these low-risk omissions.

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

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

The tool has zero parameters, so there is no parameter documentation burden on the description. The description still adds meaning by listing the contextual data sources (lead profile, campaign goal, ICP, persona) that shape the generated message, which helps the agent understand what information influences the output.

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 ('Generate'), a clear resource ('personalized LinkedIn first message'), and the context used ('full campaign context'). It also names the exact sibling alternative, campaignstack_craft_followup, so the tool is easy to distinguish from nearby craft 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?

Explicitly says 'Use only for first messages (no prior conversation)' and routes follow-ups to campaignstack_craft_followup. This gives the agent a clear decision rule for when to select this tool versus its sibling.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds useful behavioral context beyond annotations: it fetches lead profile, campaign goal, ICP, and persona data from Convex, and uses AI to generate the note. It also clarifies the tool only generates text rather than sending the connection request, which is valuable.

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-loads the key purpose and character limit, and devotes its second sentence to routing the agent to the correct sibling. Every sentence earns its place without unnecessary detail.

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

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

For a zero-parameter generation tool, the description explains what it produces, the data sources it uses, the length limit, and when to use it vs. an alternative. It could be slightly clearer about how the target lead/campaign is selected given no explicit parameters, but overall it is sufficient 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 tool has zero parameters, so the schema carries no burden. The description adds meaning by explaining that the tool automatically draws on lead profile, campaign goal, ICP, and persona data from Convex, effectively clarifying how input context is resolved despite the empty parameter list.

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

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

Description clearly states the specific action ('Generate'), the resource ('personalized LinkedIn connection note'), and the explicit constraint ('max 300 characters'). It also differentiates from nearby siblings by naming the alternative use case for first messages via campaignstack_craft_message.

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

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

Explicitly says 'Use for connection requests' and gives the when-not-to-use condition: 'For first messages after connecting, use campaignstack_craft_message.' This provides clear exclusions and routes to the correct sibling, leaving no inference needed.

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, not idempotent, and not destructive; the description aligns by making the creation side effect explicit. It adds meaningful context by stating the campaign is returned 'ready for configuration' and that the response includes the new ID and title. No contradiction with the 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?

At about 22 words, the description is compact and front-loaded with the primary action. However, 'Create a new campaign' is expressed twice, creating slight redundancy; the second sentence about return values and the third about configuration state do add useful information. Overall, it is concise without being sparse.

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 creation tool, the description covers the core purpose and return value, and required parameters are listed in the schema. But it does not explain the meaning of 'goal', optional parameters, or the output shape beyond ID and title, and there is no output schema to fill that gap. Given the low schema coverage, the definition is adequate but not fully complete.

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

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

Schema description coverage is only 25%, with only workspaceId having a description, so the tool description carries the burden of clarifying title and goal. It does not explain what 'goal' means, whether a title must be unique, or how workspaceId interacts with key types. The description adds almost no parameter-level meaning beyond what the schema already provides.

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

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

The description clearly states the action ('Create a new campaign in a workspace') with a specific verb and resource. The word 'new' distinguishes it from campaign update, delete, archive, and list operations, even without naming a sibling explicitly. It also specifies what is returned (new campaign ID and title), reinforcing the tool's 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 implies this tool is used when creating a new campaign, and 'ready for configuration' hints at a follow-up configuration step. However, it does not explicitly mention when not to use it, such as when an existing campaign should be updated via update_campaign, or when listing existing campaigns is more appropriate. Guidance is implied rather than explicit.

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

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

The description discloses meaningful behavior beyond the annotations: first-run snapshot, weekly re-read/diff, emitted company_employee_joined signal, idempotency, and per-workspace caps. It does not detail permission requirements or failure modes, but the annotations already cover safety traits like readOnly and destructive 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?

Two dense sentences carry all key information: purpose, mechanics, cadence, side effect, idempotency, cap, and sibling distinction. Nothing is wasted and the core action 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 two-parameter creation tool with no output schema, the description covers the essential operational details: what the watch does, when it runs, what it emits, and its limits. It could mention how to list, pause, or remove the watch, but those are covered by sibling tools and do not block 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 0%, so the description must compensate. It references 'company' and 'workspace' enough to imply what companyId and workspaceId mean, but it does not explicitly define the format, source, or validation of these IDs. The parameter names are self-explanatory, but the description could be more direct.

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: 'Watch a company for NEW employees' and explains the signal it emits. It also explicitly distinguishes itself from campaignstack_create_signal_watch, so an agent can tell these sibling tools 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 clearly explains the intended use case (tracking new employees at a company) and names the closest alternative, campaignstack_create_signal_watch, with the deciding condition: company-level vs person-level watching. The lifecycle (first snapshot then weekly diffs) also clarifies when ongoing behavior kicks in.

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=false, idempotentHint=false, and destructiveHint=false, so the description only needs to add non-obvious behavior. It does so by disclosing automatic deduplication by normalized LinkedIn URL within the workspace, which is valuable operational context beyond 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?

Three short sentences, each earning its place: the creation purpose, the deduplication behavior, and the pointer to list existing watches. There is no filler, repetition of schema fields, or tangential 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?

The description plus schema covers the tool's intent, key parameters, deduplication behavior, and how to inspect existing watches. With no output schema, a note about the return value would be helpful, but this is a minor gap rather than a critical omission.

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?

Although schema description coverage is only 40%, the description compensates for key required parameters: 'LinkedIn company page or influencer profile' maps naturally to profileUrl and entityType, and 'normalized LinkedIn URL' clarifies what profileUrl should contain. The optional accountIds and workspaceId already have schema descriptions, and name is self-explanatory.

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—'Creates a new competitor watch'—and immediately states its function: monitoring a LinkedIn company page or influencer profile. This clearly establishes what the tool does and distinguishes it from the broader set of watch-creation 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 provides clear usage context and points the agent to campaignstack_list_competitor_watches for viewing existing watches, which is directly relevant to avoiding duplicate creation. It does not explicitly contrast this tool with sibling watch creators like create_search_watch or create_signal_watch, but the competitor-watch scope is specific enough that the intended use is clear.

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

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

Beyond the generic annotations, the description discloses crucial behavioral details: no backfill, only one watcher allowed per LinkedIn account across workspaces, the agent is created paused, and the workflow includes AI-crafted DM, human review, send, and follow-up rounds. These are exactly the non-obvious behaviors an agent needs to set correct expectations.

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

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

Every sentence earns its place: purpose, behavior, constraint, paused state, activation path, advanced alternative, and ID lookup are all packed into a compact, front-loaded description. There is no filler or repetition of schema/annotation details.

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

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

For a creation tool with only two simple parameters and no output schema, the description is remarkably complete. It covers what is created, how it behaves, its lifecycle state, uniqueness constraint, activation requirement, and a preferred alternative. The only minor omission is workspaceId semantics, which does not meaningfully undermine an agent's ability to call the tool.

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

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

The schema has zero property descriptions, and the description compensates only partially. It explains how to find linkedinAccountId (use campaignstack_list_accounts), but it never explains workspaceId, its optional role, or how workspace scoping interacts with the one-watcher-per-account rule. The parameter names are fairly self-explanatory, but the description does not fully carry the semantic burden.

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

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

The description opens with a clear verb and resource: 'Create a connection-watch signal agent for a LinkedIn account.' It then defines exactly what the agent does (monitors newly accepted connections, routes them into a welcome workflow) and differentiates the tool from siblings like campaignstack_set_account_watcher and generic signal-agent creators.

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

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

The description gives explicit usage context: the agent starts paused, must be resumed via campaignstack_resume_signal_agent, and account IDs can be found via campaignstack_list_accounts. It also names an advanced alternative (campaignstack_set_account_watcher) and states when it is preferred, which makes tool selection unambiguous.

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

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

Annotations already indicate this is a non-readonly, non-idempotent write, so the description doesn't need to restate that. It adds useful context by clarifying the result is a draft and that postType is auto-inferred, but it doesn't disclose related behavior like how draft posts enter the approval/publishing flow or any limits beyond what annotations convey.

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

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

Three dense sentences with no filler. The core action, return value, retrieval alternative, postType behavior, and tag semantics are all present and front-loaded, making the description easy to scan.

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 creation tool with no output schema, the description covers the key outcome (new post ID), the draft nature, the companion retrieval tool, scheduling options, tag constraints, and media-based postType inference. It could mention how to obtain mediaIds or follow approval/scheduling next steps, but the description is largely sufficient 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 coverage is only 33%, so the description carries a real burden here. It compensates well by explaining the media-to-postType inference rule and differentiating system tags from freeform user tags. It does not describe mediaIds sourcing or authorAccountId semantics, but the names and schema constraints plus the inference rule cover the most non-obvious parts.

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 creates a draft content post for a LinkedIn account and returns the new post ID. The 'draft' qualifier and the pointer to campaignstack_get_content_post clearly separate it from retrieval, list, approval, and scheduling 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 explicitly tells the agent to use this tool to create a draft and directs to campaignstack_get_content_post for retrieval. It does not explicitly rule out schedule/approve siblings, but the draft semantics plus the scheduledAt/autoSchedule parameters make the intended workflow reasonably clear.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, covering the safety profile. The description adds that a new ICP is created and made available for later scoring, but it does not disclose return values or duplicate-creation behavior—modest gaps given existing annotation coverage.

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

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

The description is four short, logically ordered sentences: what the tool does, the criteria it accepts, the recommended follow-up action, and how to obtain a required value. Every sentence earns its place, with no filler or unnecessary 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 6-parameter creation tool with no output schema, the description covers all parameters at a useful summary level and names the follow-up scoring tool. It omits edge details such as whether at least one criterion is required or what the response looks like, but an agent has enough context to select and invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description carries the burden. It enumerates the five optional criteria parameters and connects campaignId to the campaign concept, even telling the agent how to source valid campaignId values. It does not define value conventions for individual criteria, but the parameter names are largely self-explanatory.

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 ('Create') and resource ('new ICP (Ideal Customer Profile)') and lists the concrete target dimensions: titles, industries, seniorities, company sizes, and keywords. It is distinguishable from get/list tools, though it does not explicitly contrast with the sibling create_persona or update_icp 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 explicit workflow guidance: after creating the ICP, use campaignstack_trigger_icp_scoring to score leads against it, and use campaignstack_list_campaigns to find valid campaignId values. It does not spell out when-not-to-use or name alternatives like create_persona, but the sequencing context is concrete and useful.

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 this as a non-read-only, non-idempotent mutation, and the description adds that it creates a new static list and can optionally add leads. However, it does not disclose uniqueness, response shape, or failure behavior, though the annotations lower the bar.

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, action-first, with no filler. Each sentence adds distinct value: the core action, optional lead addition, and prerequisite ID lookups.

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 is complete enough for selecting and invoking the tool: it covers the required campaign scope, optional leadRefs, and ID sourcing. It could mention the response/return value or point to add_leads_to_list for existing lists, but these are not blockers.

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 compensates by explaining leadRefs structure (leadSource default 'global' and leadId) and how to obtain campaign and lead IDs. It slightly overstates leadSource as 'needs' when the schema makes it optional with a default, so it is not perfect.

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

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

The description states a specific action and resource: 'Create a new static lead list in a campaign.' The word 'static' also distinguishes it from the sibling campaignstack_create_query_lead_list, so the agent can identify the correct tool immediately.

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 clear context for when to use the tool (creating a new static list) and gives concrete lookup guidance: use campaignstack_list_campaigns for valid campaign IDs and campaignstack_search_leads for lead IDs. It does not explicitly contrast with add_leads_to_list or create_query_lead_list, but 'new' and 'static' make the primary use condition clear.

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

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

The annotations already indicate this is a non-read-only, non-idempotent, non-destructive mutation. The description's 'Create a new persona' aligns with that and adds no dangerous side-effect information. It does not disclose duplicate behavior, authorization needs, or downstream effects, but the annotation coverage partially mitigates this.

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 action is stated first, the concept is clarified second, and the prerequisite lookup is given third. 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?

The description is sufficient for an agent to understand what to create, which campaign context is required, and how to obtain the campaign ID. There is no output schema and the return value is not described, but for a straightforward create operation this is a minor gap rather than a blocking one.

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 50% schema description coverage, the description adds some meaning by explaining that personas have pain points, goals, and objections, and by pointing to campaignstack_list_campaigns for campaignId. However, it does not explain the name or description parameters, and it mostly restates what the schema already describes for the array fields.

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 ('Create') and resource ('a new persona in a campaign'), and adds conceptual context about personas representing buyer archetypes. However, it does not explicitly differentiate this from sibling tools like create_icp or update_persona, so it stops short of full sibling differentiation.

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 instruction to use campaignstack_list_campaigns to find campaign IDs provides a concrete prerequisite and helps the agent gather the required campaignId. There are no explicit when-not-to-use conditions or alternative tool mentions, but the context is clear 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?

Annotations already indicate this is a mutating, non-idempotent operation (readOnlyHint=false, idempotentHint=false). The description adds useful domain context, especially that 'the order field controls phase sequencing,' but it does not disclose potential side effects, failure modes, or whether creation requires an existing campaign beyond supplying an ID.

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 tight sentences with no filler. It front-loads the core purpose, then explains phase organization and the key order-field behavior, and ends with a practical lookup tip. 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?

The description provides enough orientation for a straightforward create operation: what a phase is, that order matters, and how to obtain campaign IDs. It lacks guidance on what happens after creation, how objectives map to the phase structure, or how ordering interacts with existing phases, though the schema and mutation annotations cover some of this burden.

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

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

Schema description coverage is only 17%, so the description needs to compensate. It explains the purpose of the order field and points to campaignstack_list_campaigns for campaignId. However, it does not add meaning for objectives, name, or description beyond their obvious names, and phaseType is only 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?

The description states a specific action and resource: 'Create a new campaign phase (roadmap milestone).' It also clarifies that phases organize a campaign into sequential steps with objectives. It does not explicitly differentiate itself from siblings like update_phase or list_phases, but the 'create' and 'new' language makes the intent clear.

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

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

The description implies when to use the tool—when creating a new phase for a campaign—and provides one useful related instruction: use campaignstack_list_campaigns to find campaign IDs. However, it does not state when not to use this tool or compare it with alternatives such as update_phase or create_campaign.

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 key behavioral trait that query lists resolve members dynamically from included/excluded lists and filter rules, which goes beyond the annotations. The readOnlyHint=false already signals mutation, and the description adds useful nuance about how the list behaves.

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. The primary purpose is front-loaded, and the follow-up sentence provides actionable lookup context. 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?

Given the complex nested query schema and the absence of both an output schema and any field descriptions, the description leaves substantial gaps. An agent still lacks enough information to correctly construct the query.filter, query.logic, and query.excludedLeadIds fields. The ID lookup pointers help but do not complete the picture.

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 clarifies that campaignId and include/exclude leadListIds can be discovered via list tools, but it says nothing about the query.logic enum, the filter array structure, or excludedLeadIds. This is insufficient for a nested query object with undocumented fields.

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 operation: creating a dynamic query-type lead list within a campaign. It distinguishes this from the static create_lead_list sibling by emphasizing the 'query-type' nature and how members are resolved dynamically.

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 concrete lookup guidance: use campaignstack_list_campaigns for campaign IDs and campaignstack_list_lead_lists for include/exclude refs. However, it does not explicitly contrast this tool with the static create_lead_list or update_lead_list, so the when-not-to-use guidance is only implicit.

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

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

Annotations are all false and offer essentially no safety profile, so the description carries the full burden — and it delivers richly. It discloses the ~6-hour polling cadence, the past-24h relevance-sorted scope, the workspace-level uniqueness constraint, the fact that a conflicting watch is created but starts disabled, and the automatic ownership transfer on archival. This is exactly the kind of non-obvious runtime behavior an agent needs and could never infer from the schema or 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 longer than average but information-dense, with zero filler. It is logically structured: what the tool does, how the watch operates mechanically, the uniqueness constraint, the conflict edge case, and the pre-flight lookups. It is front-loaded with the core purpose, though the dense single paragraph without breaks is slightly harder to parse than it could be.

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 this much behavioral complexity — background scheduling, uniqueness semantics, disabled states, ownership transfer — the description covers the operational landscape impressively. The only notable gap is return value: with no output schema present, an agent is left uncertain whether the call returns a watch ID, a status, or the lead-feed behavior confirmation.

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 67%: topicId and accountIds are documented in the schema, but campaignId has no schema description. The main description compensates by establishing campaignId's role as the target campaign receiving extracted leads, and it adds conceptual meaning to topicId (a keyword monitored on LinkedIn content search, relevance-sorted) that the schema's terse "ID of the topic to watch" lacks.

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

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

The opening sentence states a specific verb and resource — "Set up a LinkedIn search watch that automatically discovers new leads for a campaign" — then precisely defines what a search watch is (monitors a topic keyword on LinkedIn content search, extracts post authors, feeds them as leads). This clearly differentiates it from sibling tools like create_competitor_watch, create_company_employee_watch, and create_signal_watch, which are all different watch types.

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 pre-flight workflow guidance: it names campaignstack_list_search_topics for checking already-watched topics and campaignstack_get_campaign_topics for topics on the target campaign, and explains the one-watch-per-topic constraint and the disabled-start fallback. It does not explicitly state when to choose this tool over the other watch-creating siblings, but the precise definition of what a search watch is makes the selection criteria reasonably inferable.

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 detail beyond the annotations, particularly that creating the agent also auto-generates a template workflow and lead list, and that accountIds observe while actAccountIds act on signals. It does not contradict the annotations, and the mutation implication of 'create' aligns with readOnlyHint=false.

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 yet information-dense, front-loading the primary purpose before detailing target variants and account roles. Every sentence contributes value, with no repetition of schema constraints or filler.

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

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

Given the complexity of the nested target object and 11 parameters, the description covers the essential decision points: what to monitor, how the target object differs by kind, and how accountIds/actAccountIds are used. It does not mention what the tool returns, but since no output schema exists and the description already explains the core creation behavior, this is a minor gap rather than a blocking one.

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 0%, the description carries the burden for parameter meaning and does so for the most complex fields: target shapes and the observer/actor distinction between accountIds and actAccountIds. It does not explain optional parameters like silenceHours, followUpDelaysHours, or publicReplyConfig, but the core required parameters are sufficiently clarified for 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?

The description clearly states the action ('Create a new signal agent'), the resource type, and the scope: monitoring a LinkedIn profile, company feed, group, or post for engagements. It also distinguishes this from similar watch tools by noting it auto-generates a template workflow and lead list, making the tool's purpose specific and actionable.

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

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

The description gives clear context on what the tool is for and includes an explicit pointer to campaignstack_list_accounts for finding account IDs. However, it does not explicitly contrast this tool with sibling tools like create_signal_watch or create_search_watch, so an agent must infer when this signal-agent variant is preferred.

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 significantly expands on the annotations by disclosing the daily refresh cadence, alert channels, monitored fields, idempotent return behavior, and the per-workspace cap on active watches. 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 compact, front-loaded with the core behavior, and every sentence adds value: monitoring behavior, idempotence, cap, and prerequisite tools. 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?

The description covers the purpose, monitoring behavior, idempotence, cap, and discovery workflow, which is strong for a tool without an output schema. The main omission is leadSource semantics and perhaps explicit cleanup/removal guidance, so it falls just short of fully complete.

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

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

Schema description coverage is 0%, and the description does not explain the leadSource parameter at all. While leadId and workspaceId are inferable from context, leadSource values ('global'/'private') remain undefined, leaving a real gap for 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?

The description states a specific verb and resource: watch a lead for profile signal changes. It explains exactly what happens (daily refresh, alerts on title, company, seniority, headline, location), which distinguishes it from related watch/agent 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 provides clear workflow context by pointing to campaignstack_search_leads for finding lead IDs and campaignstack_list_signal_watches for current watches. It does not explicitly compare to alternative watch tools, but the usage context is clear 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?

Annotations already indicate this is not read-only and not idempotent, so a mutation is expected. The description adds value by stating the success return shape ({ workflowId, nodeCount }), the default source behavior when sourceConfig is omitted, and the unsupported graph category. It does not cover failure modes or rate limits, but for a create operation these are reasonable gaps given the annotations and the explicit return contract.

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 tight and information-dense: purpose, graph structure, prerequisite discovery call, success return, default source behavior, and an explicit unsupported case. Every sentence earns its place, and the core 'Create a new workflow' directive is front-loaded. There is no filler or repetition of schema details.

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

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

This is a complex tool with nested graph and sourceConfig objects and no output schema. The description compensates well by describing the return contract, directing the agent to the authoritative node-type discovery tool, explaining the default sourceConfig, and capping applicability with the signal-intake exclusion. Combined with the 80% schema coverage, the agent has enough to invoke this correctly.

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

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

Schema description coverage is high at 80%, so the schema already documents name, graph, campaignId, workspaceId, and sourceConfig. The description adds meaningful parameter-level guidance beyond that: it explains that graph nodes are automation nodes with examples, that get_workflow_node_types should drive valid node configs, and that sourceConfig is optional with a concrete default. This pushes the value beyond the schema baseline.

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

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

The description opens with the specific verb 'Create' and the target resource 'a new workflow', then clarifies what a workflow is: a graph of automation nodes and directed edges. It distinguishes itself from the many sibling tools by focusing on graph authoring and explicitly excluding signal-intake graphs. An agent can immediately tell this is the workflow-creation tool.

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

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

The description gives explicit sequencing guidance: call campaignstack_get_workflow_node_types first to learn valid node types, configHint shapes, and the graph format. It also states a clear when-not case: signal-intake graphs with lead-list-based sources are not supported. The optional sourceConfig default behavior is spelled out, so the agent knows what happens if it omits the parameter.

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 reveals meaningful behavior beyond the annotations: accept is transactional, applies all changes through the same safeguards as a manual edit, and fails entirely if the target text changed. Reject is clearly described as applying nothing. This fully compensates for the uninformative false 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 dense sentences with no filler. The core action is front-loaded, and each clause adds necessary information: transaction semantics, failure mode, and the no-op reject behavior.

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

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

For a state-changing tool with no output schema, the description covers what the operation does, how it fails, and what reject does. The schema covers parameter provenance and workspace requirements, so an agent has everything needed to invoke it correctly.

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

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

The schema documents proposalId and workspaceId, while the decision enum lacks a description. The description compensates by explaining what accept and reject do, giving the decision parameter practical meaning. It adds value beyond the schema without needing to restate schema details.

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

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

The description opens with a precise verb and resource: "Accept or reject the pending playbook proposal." It clearly distinguishes this tool from siblings like campaignstack_propose_playbook_change and campaignstack_get_playbook_proposal by focusing on the decision 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 explicit guidance for the accept path, including the failure condition and the instruction to propose again when targeted text changed. It does not explicitly contrast with propose/revert siblings, but the decision-oriented guidance is strong enough for correct 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 say destructiveHint=true, but the description goes further by naming every data class destroyed and stating 'This action is irreversible.' This is exactly the context agents need beyond the flag.

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 high-stakes warning is front-loaded, the cascade list is dense but purposeful, and all three sentences contribute distinct guidance (action, irreversibility, alternatives). No filler.

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

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

With one self-explanatory parameter and destructive annotations already present, the description covers operation scope, irreversibility, and both failure and alternative routes. Nothing needed 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?

The schema's single campaignId parameter has no description, but the tool name and cascade language make its meaning clear. The fallback guidance to list_campaigns for valid IDs adds semantic value about the expected value domain.

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 the operation with a specific verb ('PERMANENTLY delete') and resource ('a campaign'), then enumerates the exact cascade scope. Clearly distinct from archive_campaign and other campaign 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?

Explicitly tells when to use archive_campaign instead ('to preserve data') and how to recover from a bad campaignId via list_campaigns. This is textbook routing between siblings.

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

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

Annotations already carry the destructive profile (destructiveHint=true), so the bar is lower. The description adds value beyond that by specifying what gets destroyed — the watch plus its associated automations — and by clarifying permanence ('This action is irreversible'), which is more specific than a generic destructive flag.

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, each earning its place: core action plus side effect, irreversibility warning, and alternative routing. The core behavior is front-loaded with 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 one-parameter destructive tool with annotations already covering the safety profile, the description covers purpose, side effects, permanence, and the key alternative. It is missing only minor details such as behavior on a nonexistent watchId or the expected response, which are not critical for a simple delete.

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. Although watchId is not explicitly documented, 'Deletes a competitor watch' makes the parameter's semantic role unambiguous: watchId identifies which competitor watch to delete. For a single, trivially inferable string parameter this is sufficient compensation.

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 ('Deletes a competitor watch') and discloses the key side effect ('disables its associated automations'). It also names the sibling that does something different (pause), so an agent can distinguish delete from pause 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 explicitly routes the agent: 'Use campaignstack_pause_competitor_watch to temporarily stop monitoring instead,' establishing when-not (temporary cases) and naming the exact alternative. The contrast with the pause sibling makes the permanent-deletion use case unambiguous.

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 and readOnlyHint=false. The description adds valuable behavioral context beyond the annotations: deletion is restricted to draft/failed posts, implying failed attempts for other statuses. It doesn't describe error behavior or side effects, but the key extra constraint 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?

Two short sentences with no filler. The action is front-loaded, the precondition follows immediately, and the helper reference is placed at the end. Every sentence earns its place.

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

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

For a simple one-parameter destructive operation, this is complete. The description covers what it deletes, when deletion is valid, and how to verify before calling. No output schema exists, so not describing return values is appropriate.

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 only parameter, contentPostId, is self-explanatory from its name. The description adds meaning by indicating that the ID must reference a post in draft or failed status, and it points to a getter for verification. This compensates for the sparse 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 uses a specific verb ('Deletes') and resource ('a content post'), and adds a precise status constraint. This clearly distinguishes it from other delete_* siblings and identifies the object of the operation.

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 states when deletion is allowed (draft or failed status) and tells the agent to use campaignstack_get_content_post to check status first. This gives both a precondition and a concrete alternative/helper 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?

The annotations already mark the tool as destructive and not read-only, but the description adds important context: the deletion is permanent, irreversible, and cascades to associated scoring data. This goes beyond the annotation flags and helps the agent warn users appropriately.

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

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

Two concise sentences: the first states the action and key consequence, the second gives the prerequisite lookup step. Every sentence earns its place, with no redundant 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 covering read-only/destructive/idempotent hints, the description is complete. It covers what is deleted, the irreversibility, the cascading data removal, and how to obtain the required ID.

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 one parameter, icpId, with 0% description coverage. The description tells the agent to find ICP IDs via campaignstack_list_icps, which provides practical sourcing guidance, but it does not clarify expected format, examples, or any nuance about the ID beyond its name.

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 ('delete'), a clear resource ('an ICP'), and the extended scope ('its associated scoring data'). It clearly distinguishes this tool from related siblings like create_icp, update_icp, get_icp_scores, and list_icps.

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 directs the agent to use campaignstack_list_icps to find ICP IDs before deleting, which is a concrete prerequisite. It does not explicitly state when not to use this tool, but for a deletion operation the guidance is reasonably 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 include destructiveHint=true, so the destructive nature is known. The description adds value by stating the deletion is permanent and cannot be undone, which goes beyond the annotation's generic destructiveness signal and warns the agent about irreversibility.

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 only two sentences, with the core action front-loaded first, followed by the critical irreversibility warning and a targeted prerequisite instruction. Every clause earns its place.

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

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

For a simple single-parameter destructive tool, the description provides the necessary action, permanence warning, and a safe invocation pattern. No output schema is needed for the agent to understand that the deletion result is all-or-nothing.

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 carries the burden of explaining the personaId parameter. While it does not directly define 'personaId,' instructing the agent to confirm the ID via campaignstack_list_personas adds meaning about how to obtain a valid value before calling the 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 states a specific verb and resource: 'Permanently delete a persona.' This immediately distinguishes it from create, update, get, and list persona tools, and it explicitly notes that deletion is permanent.

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 clear pre-use guidance: 'Use campaignstack_list_personas to confirm the persona ID before deleting.' This is practical and context-rich, though it does not enumerate explicit when-not-to-use scenarios or mention alternative deletion-related tools.

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

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

Annotations already declare destructiveHint=true, but the description adds a crucial behavioral detail beyond that: 'This action cannot be undone.' This clarifies irreversibility and reinforces the need for caution, providing value beyond the structured annotation.

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

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

Two short sentences carry all essential information: the action, its irreversibility, and a safety step. There is 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?

For a one-parameter destructive action without an output schema, the description is largely complete. It explains the operation, the irreversibility, and how to safely obtain the required ID. It does not describe cascading effects on related campaign data, but this is a minor gap given the simplicity of the tool.

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

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

Schema coverage is 0% and phaseId is only described as a string. The description compensates by identifying the parameter as a campaign phase ID and instructing the agent to confirm it via campaignstack_list_phases, which gives practical sourcing semantics beyond the bare schema.

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

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

The description opens with a clear verb and resource: 'Permanently delete a campaign phase.' It unambiguously distinguishes this from sibling tools like campaignstack_update_phase, campaignstack_get_phase, and campaignstack_list_phases by emphasizing permanence and deletion.

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 explicit pre-use guidance: use campaignstack_list_phases to confirm the phase ID before deleting. This tells the agent exactly what to do before invoking the tool, though it does not explicitly cover when-not-to-use scenarios or alternative non-destructive actions.

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 destructive and idempotent behavior; the description adds valuable detail by explaining exactly what gets disabled, that it is a soft-delete, and that data is preserved for audit. This goes well beyond 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?

Four ideas packed into three tight sentences with the main action front-loaded. There is no filler, and every sentence contributes either to identifying the behavior, its consequences, or how to obtain the required parameter.

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 operation, side effects, data preservation, and ID lookup, which is strong for a one-parameter tool. It stops short of stating whether the archive action is reversible or if a new agent must be created to restore functionality, which would be useful context for a destructive 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?

The schema provides no description for agentId, but the description compensates by naming the resource as a signal agent and telling the agent where to find valid IDs via campaignstack_list_signal_agents. For a single simple string parameter, this is adequate guidance.

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

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

States a precise action: 'Archive (soft-delete) a signal agent.' The side effects listed (stops polling, pauses workflow, disables watched posts, clears competitor linkage) clearly distinguish it from generic delete operations and from pause/resume sibling tools.

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

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

Provides clear operational context and explicitly instructs the agent to use campaignstack_list_signal_agents to find valid agent IDs. It does not explicitly name alternatives like pause_signal_agent or state when not to use this tool, but the archiving semantics are clear enough to guide 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 mark the operation as destructive, but the description adds valuable specifics: the deletion is irreversible and cascades through workflow nodes, edges, lead-list source providers, lead progress entries, per-lead contexts, and webhook tokens. This goes well beyond the annotation and accurately discloses the full destructive footprint.

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 filler. The irreversible action and cascade scope are front-loaded, followed immediately by actionable lookup guidance and the safe alternative. Every sentence serves a distinct 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?

For a one-parameter destructive tool with no output schema, this description is complete: it states the action, the irreversible consequences, the full cascade of affected data, how to obtain the required ID, and the non-destructive alternative. An agent has everything needed to invoke this tool correctly and avoid harmful mistakes.

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 only defines workflowId as a required string with no description, so schema description coverage is 0%. The description compensates by telling the agent to use campaignstack_list_workflows to find workflow IDs, clarifying where the parameter value comes from. It does not elaborate further on the parameter's meaning, but the parameter name and this guidance are sufficient for such a simple 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 verb and resource: 'Permanently delete a workflow and all associated data.' It immediately distinguishes this from non-destructive workflow operations and clearly defines the scope of the deletion, making the tool's 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 explicitly tells the agent how to find the required workflow ID using campaignstack_list_workflows, and explicitly names the alternative when deletion is not intended: campaignstack_update_workflow_status. This gives clear when-to-use and when-not-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 declare readOnly, idempotent, and non-destructive behavior. The description adds a detailed account of what the diagnostic report covers: lead existence, ICP score, threshold checks, dedup status, exclusions, per-provider filters, and a verdict. This goes well beyond the annotation hints and makes side-effect expectations explicit.

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 lengthy but every clause adds information: purpose, accepted inputs, report contents, and lookup helpers. It is front-loaded and avoids filler, though the list of report categories makes it denser than necessary.

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 diagnostic tool with no output schema, the description covers inputs, the full scope of the report, and how to obtain valid identifiers. The main gap is the mismatch between the described parameters and the empty input schema, which leaves the actual call contract ambiguous.

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

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

The input schema has zero properties, so the description is the only source of parameter meaning. It clearly names workflowId and the leadId-or-profileUrl choice and notes that profileUrl is a LinkedIn URL. It loses a point because it omits types for workflowId and leadId and because the described parameters are absent from the structured schema, which could confuse 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?

The description opens with a specific verb and object: 'Diagnose why a specific lead was or wasn't sourced into a workflow.' It then enumerates the report contents, making the tool's purpose unmistakable and distinguishing it from lookups like search_leads or get_lead_history.

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 names the two lookup tools to call for valid workflowId and leadId values and states the accepted identifier combination. It doesn't explicitly contrast with alternative diagnostic tools, but the context of sourcing diagnosis is clear.

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

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

Beyond the annotations (destructiveHint=true, idempotentHint=false), the description discloses what actually gets destroyed — 'the integration record and its stored credentials' — and that the deletion is permanent. This tells the agent the action is irreversible and that reconnecting would require fresh authentication, which is precisely the behavioral context annotations cannot convey.

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

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

Four short sentences, each earning its place: the action, the irreversible consequence, the provider set, and the pre-check pointer. It is front-loaded with the core action and consequence. The provider sentence is partly redundant with the schema enum, which keeps this from a 5.

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

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

For a 2-parameter destructive tool with annotations, a 100%-covered schema, and no output schema, the description covers action, consequence, provider set, and pre-check guidance. The notable gaps are the unresolved hubspot discrepancy between description and schema enum, and no statement of behavior when the provider isn't connected — minor for a tool this simple.

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%: both provider (with enum) and workspaceId (with user-key vs workspace-key semantics) are already documented, so the baseline of 3 applies. The description's provider list 'apollo, instantly, clay' is redundant with the schema enum and conflicts with it by omitting hubspot, creating ambiguity about whether hubspot can be disconnected. No additional meaning is added 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 names a specific verb and resource — 'Disconnect (remove) an integration by provider' — and specifies the full consequence: 'Permanently deletes the integration record and its stored credentials.' It clearly inverts the sibling connect tools (campaignstack_connect_apollo, campaignstack_connect_instantly, campaignstack_connect_hubspot) and can't be confused with the list or get 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 precondition pointer: 'Use campaignstack_list_integrations to see which integrations are connected,' which is exactly the right pre-check before a destructive call. It doesn't state when not to use the tool or explicitly contrast it with the many remove_* siblings, but the inverse relationship to the connect tools makes the usage context reasonably clear.

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

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

The description adds useful behavioral detail beyond the annotations: it states that body, platform, author, and media are copied, lifecycle fields are cleared, and a new post ID is returned. Since the annotations already indicate this is a mutating, non-idempotent, non-destructive operation, this is sufficient 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 concise sentences convey the operation, copied fields, cleared lifecycle fields, and return value with no filler or redundant restatement of the tool name.

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 operation with no output schema, this description is complete: it explains what happens, what is inherited, what is reset, and what the caller receives. No critical operational detail appears to be missing.

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

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

The input schema has no description for contentPostId and schema coverage is 0%, so the description must compensate. The phrase 'existing content post' makes it clear that contentPostId refers to the post being duplicated, but the parameter itself is never explicitly documented or connected to a source.

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 ('Duplicates') and identifies the exact resource ('an existing content post') and outcome ('as a new draft'). It also names what is copied and what is cleared, making its role clear against siblings like create_content_post or update_content_post.

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

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

The intended use is strongly implied: use this when you need a clean draft copy of an existing content post. However, the description does not explicitly state when to choose this over create_content_post or update_content_post, nor does it offer any exclusions or alternative guidance.

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

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

Beyond the annotations, which only indicate the operation is not read-only and not idempotent, the description adds meaningful behavioral detail: the original content is preserved for audit trail, the lead advances via the 'approved' edge, and escalated actions are resumed with the edited text. This gives the agent a clearer picture of side effects and workflow impact.

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

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

The description is compact and front-loaded, with the core action in the first sentence and supporting workflow details in the next two sentences. Every sentence provides useful information, and there is no filler or repeated schema content.

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

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

The description explains the two workflow scenarios and their outcomes well, which is helpful for tool selection. However, it lacks parameter-level guidance and does not describe the expected shape of updatedContent or what the caller should provide beyond 'edited text,' leaving some invocation ambiguity.

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

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

Schema description coverage is 0%, so the description must compensate for the lack of parameter documentation. It only hints at updatedContent through 'your edited text' and never explains the meaning or expected structure of entryId, workspaceId, or updatedContent. The agent is left to infer parameter roles from names alone.

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

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

The description clearly states the tool's function: edit AI-generated content and approve a review entry. It implicitly differentiates itself from related siblings like approve_review by adding the editing step, but it does not explicitly name any sibling or contrast itself with them.

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

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

The description provides clear contextual usage by describing two distinct workflow states: a draft parked at a review node and an escalated entry parked at the acting node. It does not explicitly say when not to use the tool or name alternative tools such as approve_review or reject_review, but the context is clearly 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 this as a non-read-only, non-destructive, idempotent operation. The description adds useful behavioral context: the scheduled slot is preserved, in-flight sends are refused with DRAFT_ALREADY_DISPATCHING, and non-scheduled entries are refused with DRAFT_NOT_SCHEDULED. No contradiction with annotations appears.

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: the first states the operation and key preservation guarantee, the second explains content shape, and the third covers failure modes and source of valid entries. Everything earns its place.

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

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

For a mutation tool, the description covers what is edited, what is preserved, when it fails, and how to locate eligible entries. There is no output schema, but the success path is simple enough not to require a return-value breakdown. A minor gap is not describing a success response or exact contents of updatedContent beyond { messageText }.

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

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

The input schema has zero descriptions, but the description clarifies the otherwise-opaque updatedContent object by referencing the content shape of campaignstack_edit_and_approve_review and giving { messageText } as an example. entryId and workspaceId are left to be inferred from their names and the description context, which is acceptable though not explicit.

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: 'Change the text of an approved message that is still waiting at its send node, keeping its scheduled slot.' It clearly distinguishes this from related tools like campaignstack_edit_and_approve_review by emphasizing the scheduled, already-approved state and slot preservation.

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 applicability conditions: the message must be approved and still waiting at its send node. It names the content-shape reference tool, describes when the tool refuses (in-flight send or non-scheduled entry), and points to where valid entries come from, giving an agent clear routing information.

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

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

Beyond the annotations, the description adds valuable behavioral detail: it never overwrites first-party data and only fills empty fields, it charges no CampaignStack credits, it polls for the provider result in the clay path, and it enumerates the possible return statuses and error codes. This fully discloses side effects and external dependencies.

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: fields, provider behavior, overwrite semantics, pricing, return contract, and prerequisite are all covered without repetition. It is 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?

With no output schema, the description carries the full burden of explaining what the caller receives, and it does so thoroughly: status values, fieldsWritten, not_found, error categories, and prerequisite integration failures. Combined with the side-effect and pricing details, an agent has enough context to invoke and interpret 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 coverage is 100%, so the baseline is 3. The description adds meaningful semantics beyond the schema by clarifying the default provider, how clay consumes clayRoutineId, the polling behavior, and the prerequisite of a connected integration. It does not add much for workspaceId, but the schema already describes it adequately.

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: 'Enrich a company's firmographics' and lists the exact fields addressed, distinguishing it from the sibling campaignstack_enrich_lead_contact_info. It also clarifies scope with 'Single company' and names the provider param, so an agent can select it accurately.

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

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

The description gives clear usage context: it requires a connected integration, names the prerequisite tool explicitly ('use campaignstack_connect_apollo first'), and explains provider choices. It does not explicitly contrast with sibling enrichment tools, but the 'Single company' and firmographics focus make the intended use obvious.

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

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

The description goes well beyond the annotations by disclosing asynchronous behavior (status pending with requestId), credit reservation/refund mechanics, write-back rules (fill-empty, never overwrite, upgrade-to-verified), the masked-email policy, and specific error codes. This is high-value behavioral context for a mutation 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 long and dense but every sentence carries decision-relevant information for a complex provider-parameterized, asynchronous, credit-billed operation. It is front-loaded with the core action and write-back rules. A structured bullet layout would improve scannability, but there is no real 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?

With no output schema and seven parameters including provider-specific variants, the description covers the full lifecycle: request, pending, success, not-found, and error states, plus polling routes and integration prerequisites. An agent has enough context to invoke the tool correctly and handle asynchronous 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?

Although schema coverage is 86%, the description adds substantial meaning beyond the schema: provider-specific credit costs, defaults for provider and instantlyEnrichments, the fact that revealPhone is ignored for non-bettercontact providers, clayRoutineId's requirement and sourcing, and provider-specific async behavior. It transforms parameter names into actionable decisions.

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: 'Resolve a lead's work email' via named providers, and clarifies it operates on a single lead. It also distinguishes itself from related tools by stating the write-back behavior and credit implications, so an agent can differentiate it from enrichment and lead-update 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 clear provider-selection guidance: bettercontact needs no integration, while apollo, instantly, and clay require connected integrations. It also names the polling tools to use after a pending result. It does not explicitly contrast itself with nearby alternatives like update_lead_contact_info or priority_enrich, but the intended use context is strongly implied.

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

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

Annotations already mark this as read-only, idempotent, and non-destructive. The description adds meaningful behavioral detail beyond that: one row per accepted AI craft, precise field contents, newest-first ordering, and cursor-based pagination. This gives the agent a strong model of what the call returns and how it behaves.

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 dense sentences with no filler. The first sentence states the resource and row contents; the second gives concrete use cases. Everything earns its place and important details are 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 an export tool with no output schema, the description clearly defines what rows are returned and what fields they contain. Combined with fully documented parameters and annotations covering the safety profile, an agent has enough information to invoke this tool correctly.

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

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

Schema description coverage is 100%, so all five parameters are already documented. The description adds ordering and pagination context that relates to limit/cursor, but doesn't need to and doesn't attempt to redefine parameter semantics. Baseline 3 is appropriate because the schema carries the parameter documentation burden.

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

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

The description begins with a specific verb and resource: 'Export craft audit log rows for a workspace', then enumerates the exact row contents (prompts, model output, final text, attempt count, refs). This clearly distinguishes the tool from the many sibling list/get/export tools and is far from tautological.

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 use cases: 'diagnose a bad draft from what the model was actually shown, or to assemble a grading set.' It does not name specific alternative tools or state when not to use it, but the context is clear enough for an agent to route appropriately.

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 no safety hints, but the description discloses critical behavior: the job runs in the background, only one extraction per company runs at a time, re-running updates existing leads without duplicating them, and extraction is capped at LinkedIn's 1000-result ceiling. This materially shapes how an agent should invoke and monitor 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?

Four tight, front-loaded sentences with no wasted words. Every sentence adds operational value: what it extracts, cap/filter behavior, downstream read/act tools, background execution, and company ID lookup.

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

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

For an async tool with no output schema, the description explains where employees land and how to retrieve/act on them, which is helpful. However, it does not say what the call itself returns or how to check job completion/status, leaving the agent uncertain whether to poll and what a successful invocation looks like.

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 25%, so the description must compensate. It adds useful cross-reference for companyId (use campaignstack_list_companies) and gives the LinkedIn ceiling context for maxResults, but it says nothing about workspaceId and does not clarify the default behavior when maxResults is omitted. It partially compensates but leaves 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?

States a specific verb and resource: extract a company's employees from its LinkedIn People page, with an explicit cap and optional job-title filter. It also names distinct downstream tools (list_company_employees, add_leads_to_list), so an agent can tell extraction apart from reading or adding 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?

Provides a clear workflow: find company IDs with campaignstack_list_companies, extract here, then read with campaignstack_list_company_employees and act with campaignstack_add_leads_to_list. It also states an important exclusion ('They are NOT added to any lead list'). It does not explicitly contrast with campaignstack_create_company_employee_watch for ongoing monitoring, 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?

The description goes well beyond the annotations by disclosing concrete behavioral and side-effect details: the result is saved as a DRAFT profile, a human must approve it before it touches messages, and it charges voice_extraction credits refunded on failure. This gives the agent a clear picture of persistence, safety, and cost implications.

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 tight sentences deliver purpose, prerequisites, workflow outcome, and cost behavior with no filler. The most important action is front-loaded, and every sentence adds 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 prerequisites, the draft/approval lifecycle, and credit side effects, which is strong. However, since there is no output schema, explicitly stating what the tool returns (e.g., a draft profile ID or confirmation) would make it fully complete for an agent.

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

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

Schema description coverage is 100%, so the schema already explains each parameter adequately. The description adds some useful context by noting the 50-message minimum, which aligns with analysisMessageCount's minimum, but does not materially expand parameter meaning beyond the schema.

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

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

The description opens with a specific verb and resource: 'Run voice extraction for a LinkedIn account from its stored message history.' It clearly differentiates this generative/extraction action from sibling tools like get_conversation_voice or update_conversation_voice by emphasizing the extraction and DRAFT-approval 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?

It gives clear context on when the tool is appropriate: when voice extraction is needed from stored message history, with the prerequisite of at least 50 usable human-written messages and automatic backfill. It does not explicitly name alternative tools or exclusion criteria, but the context is strong enough for an agent to pick this over read/update voice 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?

Beyond the annotations (readOnlyHint=false, idempotentHint=false, destructiveHint=false), the description adds valuable behavioral context: it records edges, consumes one LinkedIn search per call, has a daily quota on the free tier, and may return skipped when the lead lacks a member id. This helps an agent anticipate side effects and constraints that annotations alone do not convey.

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

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

The description is concise and front-loaded: the core action appears in the first sentence, followed by the value proposition, cost constraint, and prerequisite. Each sentence earns its place, though the middle sentence about turning the graph into an actual network is slightly rhetorical. Overall it is well-structured and not padded.

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

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

With no output schema, the description should carry return-value and failure semantics, and it partially does by mentioning the 'skipped' outcome. However, it does not describe what a successful response contains, how edges are returned or acknowledged, or what happens on repeated calls. The leadSource parameter is also absent, leaving a meaningful gap in the overall context.

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

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

The schema has 0% description coverage, so the description must compensate. It contextualizes workspaceId ('the workspace's LinkedIn accounts') and leadId ('a lead shares'), but leadSource is never mentioned, and the meaning of 'global' vs 'private' remains unexplained. With three parameters and one entirely unaddressed, the description only partially compensates for the schema's lack of parameter 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 uses a specific verb ('Scrape') and names the exact resource and outcome: the people a lead shares with one of the workspace's LinkedIn accounts, recorded as person-to-person connection edges. It clearly differentiates this from read-only graph tools by emphasizing that it builds the network graph, making it distinct from siblings like get_lead_connections.

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 concrete when-to-use guidance: it consumes a LinkedIn search quota, so it should be called for 'leads that matter rather than in bulk.' It also states an explicit prerequisite: the lead must have a LinkedIn member id, and instructs the agent to enrich first if the call returns skipped. It does not name specific alternative tools, but the usage context is clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description adds useful behavioral context: 1st-degree results mean immediate messaging potential, no connection request is needed, and no connection budget is spent. It does not describe the exact output envelope or pagination, but that is not a serious omission here.

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 purposeful sentences: the core operation, the result interpretation, and the usage recommendation. It is front-loaded, free of redundancy, and every sentence adds 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?

For a read-only lookup with no output schema, the description gives enough to understand what the tool does, what a result means, and when to call it. The only meaningful gap is the undocumented leadSource parameter, which is optional and has a default.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It indirectly clarifies workspaceId and leadId by referencing a workspace's accounts and a lead, but it gives no explanation of the leadSource enum values 'global' vs 'private'. Since leadSource has a default and is optional, the gap is moderate 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 states a specific operation: checking which of a workspace's LinkedIn accounts can already reach a given lead. It also clarifies what a 1st-degree result means, which distinguishes this lookup from sending or queuing actions like send_connection_request or queue_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 explicitly tells the agent to call this before queueing outreach and explains the benefit: using an existing connection avoids waiting and spends no connection budget. It does not mention when not to use it or name an alternative tool, 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?

The description goes well beyond the annotations by disclosing that this action is subject to daily profile_follow budgets and business hours gates, and that a bypass disables ALL LinkedIn safety limits. It also warns that the account may be flagged or restricted, which is critical behavioral risk information not present in 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 somewhat long but every section earns its place, especially the safety warning. It front-loads the core purpose and then flows naturally into target resolution, account selection, and risk disclosure. The 'When true' clause is slightly vague, but the overall structure is informative and not padded.

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

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

For a tool with zero declared schema parameters and no output schema, the description does a strong job of covering how to identify the target, how to handle multiple accounts, and what risk the action carries. It falls just short of fully complete because the bypass parameter is not named and no return or success indication is described, but an agent has enough 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?

The input schema declares zero properties, so the description carries the full burden of documenting parameters. It explains platform, profileUrl, leadId, accountId, and the existence of a bypass flag. However, the bypass flag is referred to only as 'When true' without a parameter name, and the description does not specify the expected argument format precisely, 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 names a specific verb ('Follow') and a specific resource ('a profile') and clarifies the semantics as the network-level follow action. It distinguishes this from related engagement actions like liking or commenting, and from connection requests, so an agent can select it confidently.

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 concrete usage context: platform is required, target can be either a profileUrl or leadId, and accountId is needed only when multiple LinkedIn accounts exist, explicitly pointing to campaignstack_list_accounts as the discovery method. It does not explicitly contrast with alternative tools, but there is no obvious sibling for following profiles, so the provided guidance is sufficient.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful context about what data is returned but does not disclose edge-case behavior (e.g., not-found behavior, staleness, or timing). No contradiction exists.

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

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

Three sentences with no filler: the first states what the tool returns, the second states requirements, and the third gives lookup guidance. The most important information is front-loaded.

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

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

For a two-parameter, read-only getter with no output schema, this description is complete: it explains the purpose, required parameters, and how to source the non-obvious accountId. No critical context 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 only 50% because accountId lacks a description, and the description compensates by identifying list_accounts as the source for valid accountId values. It also confirms the platform enum values. It could add more about the expected form of accountId, but the added guidance is materially useful.

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 ('Get') and a well-scoped resource: 'detailed account health info,' and enumerates concrete contents (status, budget usage per action type, ramp-up state, last activity timestamps). This clearly separates it from list_accounts and other account-adjacent tools without needing to inspect schemas.

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

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

The description states required inputs (platform and accountId) and tells the agent to use campaignstack_list_accounts to discover valid accountId values, which is practical selection guidance. It does not explicitly name alternatives or exclusion cases, such as when to use get_account_maintenance instead, 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 declare readOnlyHint, idempotentHint, and destructiveHint false. The description adds meaningful behavioral context beyond those: cross-workspace watchers are redacted to isSameWorkspace false with no details, and the owner workspace is the one that pays for watchers and inbox sends. This is exactly the kind of hidden behavior 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?

The description is front-loaded with the core purpose and then provides a structured inventory of returned fields. It is a bit dense and the owner clause is convoluted, but there is no filler and the closing sentence adds useful navigational guidance.

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

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

With no output schema, the description compensates by enumerating the main returned categories and the important cross-workspace visibility rule. It is complete enough for an agent to call the tool correctly, though it leaves workspaceId semantics underspecified and does not describe the exact response shape.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining both parameters. It indirectly references linkedinAccountId via 'for a LinkedIn account' and 'use campaignstack_list_accounts to find account IDs,' but it never names workspaceId, never states that linkedinAccountId is required, and does not explain how workspaceId affects the result. This is a meaningful gap.

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

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

The description states a clear verb and resource: it reads per-account housekeeping state for a LinkedIn account. It enumerates the specific state groups returned (invitation hygiene, connection watcher, message watcher, owner) and distinguishes itself from related siblings by pointing to campaignstack_list_accounts and campaignstack_set_account_watcher.

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 concrete guidance on how to find account IDs (campaignstack_list_accounts) and how to change a watcher (campaignstack_set_account_watcher), which helps an agent select the right sibling. It implies when to use this tool by defining it as the read of maintenance state, but it does not explicitly contrast it with other get_* tools or state when workspaceId should be supplied.

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 read-only, idempotent, and non-destructive behavior. The description adds useful lifecycle context ('in-flight or recently completed'), a status vocabulary, and the presence of an error message, supplementing 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?

Three concise sentences front-load the purpose, then state the return payload, then give sequencing and parameter linkage. No redundant or filler content.

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

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

For a simple read-only polling tool with no output schema, the description covers invocation timing, required parameter correlation, return fields, statuses, and error behavior. An agent has everything needed to call and interpret the tool correctly.

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

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

The schema only describes workspaceId, so schema coverage is 50%; the description compensates for the required listId parameter by saying to use the same listId passed to import_apollo_list. This is the most important semantic for correct invocation, although workspaceId receives no additional description here.

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

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

The description uses a specific verb and resource: 'Get the progress of an in-flight or recently completed Apollo list import.' It enumerates the exact returned fields and statuses, which clearly separates it from the import action and from external-import progress 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 explicitly tells the agent to poll this after campaignstack_import_apollo_list, frames it as tracking large imports, and instructs reuse of the same listId. This is direct, actionable 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 declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is known. The description adds beyond annotations by disclosing the bounded result set ('last 10 jobs') and the included fields ('status, timestamps, and results'). No contradiction exists.

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

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

Two short sentences with no filler: the first states the operation and resource, the second specifies the output. Everything included earns its place, and nothing redundant repeats annotation 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 single-parameter read-only query with no output schema, the description adequately covers what the tool does and what it returns, including the result limit and fields. Minor ambiguity about what counts as 'scheduled' is acceptable and does not impede correct 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 description coverage is 0%, so the description must add meaning. It does so by linking automationId to 'a scheduled automation' and explaining what the returned history contains, making the parameter's role clear despite the bare schema.

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

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

The description states a specific verb ('Get'), resource ('job execution history'), and scope ('for a scheduled automation'), and specifies the output ('last 10 jobs with status, timestamps, and results'). This clearly distinguishes it from sibling tools like list_automations or get_workflow_stats.

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