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

Annotations already declare it is a non-destructive write with openWorldHint, so the description needn't restate safety. It does add real behavioral value by disclosing deduplication of existing identities, but it leaves open whether a duplicate is a silent no-op or an error, and says nothing about what the idempotency_key guarantees.

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

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

Two tight sentences with zero filler; the primary action is front-loaded. It is efficient rather than bloated, though the brevity is under-specification rather than disciplined economy.

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 10-parameter mutation with 0% schema description coverage and no output schema. The description never clarifies which identity fields are required versus optional, what dedup returns to the caller, or how idempotency_key should be generated, so an agent cannot call it confidently.

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

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

Schema description coverage is 0% across 10 parameters, so the description must carry the burden and it largely does not. 'Canonical identity or manual username' hints at the creator_id/origin_id versus username split, but nothing explains campaign_id, platform, idempotency_key, email, nickname, country, or notes.

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

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

Clear verb+resource: adds a creator to a campaign, and it names two intake modes ('canonical identity or manual username'), which helps distinguish it from update_campaign_creator and copy_campaign_creators. It does not explicitly name or contrast any sibling, 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?

There is no explicit when-to-use guidance and no mention of the obvious alternatives (update_campaign_creator, prepare_campaign_creator_selection, copy_campaign_creators, create_campaign_creator_import). Usage is only inferable from the tool name and the two intake modes mentioned.

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

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

The description adds useful behavioral detail beyond annotations: non-processing state restrictions and the fact that it returns the actual state if the job already finished, which prevents false error assumptions. Annotations already clarify it is non-read-only and non-destructive, so this is stronger than baseline, though it does not explain idempotency or permission requirements.

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-loaded with the cancellation scope, followed by the key restriction and edge-case return behavior. Every sentence earns its place with no redundancy.

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

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

For a mutation tool with no output schema and basic annotations, the description covers state gating and the already-finished case. However, it omits explanation of the two required parameters and does not describe authorization or side effects of cancellation, leaving meaningful gaps.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It never explains 'campaign_id' or that 'reference' is a typed object accepting either a job or handoff UUID, leaving the agent to infer the parameter structure entirely from the schema.

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

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

The description states a specific verb ('Cancel') and resource ('pending handoff or awaiting-upload/queued job'), making clear it is a cancellation tool for unstarted imports. It does not explicitly name sibling tools such as confirm_campaign_creator_import, but the state qualifiers distinguish it well enough.

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

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

It clearly states when cancellation is allowed ('pending handoff or awaiting-upload/queued job') and when it is not ('Processing jobs cannot be cancelled'), providing strong usage context. It does not name an alternative action for processing jobs (e.g., check status via get_campaign_creator_import), so it stops short of full alternative routing.

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

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

Annotations already flag destructiveHint=true and openWorldHint=true, so the safety profile is known. The description adds genuinely new behavioral context the agent can't infer: only pending sends are affected and delivered mail cannot be recalled. It omits retry-after-cancel expectations and idempotency semantics, which is a real but secondary 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 tightly written sentences, irreversibility caveat front-loaded after the scope statement. Nothing redundant and no filler.

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

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

With no output schema and a destructive, open-world operation, the description covers irreversibility of delivered mail but not what the response reports (counts of cancelled vs skipped), how partial eligibility failures behave, or why idempotency is mandatory. Adequate to act safely, incomplete for predicting outcomes.

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

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

Schema description coverage is 0% for three required parameters, and the description says nothing about wave_id, idempotency_key, or the confirmation const 'user_authorized'. The agent must infer that cancel requires an explicit authorization token and a unique idempotency key from the raw schema alone — the definition does not compensate.

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 (stop pending sends in a wave), which clearly separates it from read-oriented siblings like get_campaign_email_wave and list_campaign_email_waves. The 'eligible pending sends' phrasing adds scope precision, though it stops short of naming the trial alternative (retry_campaign_email_wave) explicitly.

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

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

'In an explicitly approved wave' implies a precondition (approval) without stating how an agent confirms eligibility or what to do if the wave is not approved. No mention of when to prefer get_campaign_email_wave/retry_campaign_email_wave instead. Usage is implied, not directed.

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 openWorldHint=true, so the description doesn't need to re-assert that cancelling is a write. It adds the useful scoping that only pending, pre-approved transfers are eligible. It does not say whether cancellation is reversible, whether in-flight data is discarded, or that a confirmation token is mandatory — gaps that matter 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?

Two short sentences, zero padding, with the eligibility constraint front-loaded ahead of the exclusion. Nothing could be cut without losing 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, no-output-schema mutation this is only partially complete: eligibility and the redirect to the removal tool are covered, but the required confirmation semantics and irreversibility are absent. Adequate to select the tool, insufficient to invoke it confidently.

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 full burden, and it explains neither transfer_id (a UUID identifying which upload) nor confirmation (a const 'user_authorized' string). The phrase 'explicitly approved' faintly gestures at the confirmation parameter but never tells the agent it must pass that literal value.

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

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

States a specific verb+resource ('Cancel ... pending upload') and constrains it to an 'explicitly approved' upload, which is meaningfully more precise than the title. It differentiates itself from the file-removal path, though it never names the sibling tool it points at.

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 both a when ('pending upload' that is 'explicitly approved') and a when-not ('Completed campaign files use their removal tool'), which is real routing guidance. The alternative is described obliquely as 'their removal tool' rather than naming remove_campaign_file, leaving a small inference step.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is largely covered. The description adds useful scope context: it only checks the targeted recipients and returns guidance rather than sending, reinforcing the dry-run nature. It stops short of saying what failure/unsendable outcomes look like or that it has no side effects on data.

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

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

Two tight sentences with no filler; the defining fact (final dry-run gate before bulk email) is front-loaded, and the second sentence covers requirements and 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 gate tool with no output schema, the description says it 'returns sendability guidance' but not the shape or what a negative result implies, and it does not explain kind/threading. Enough to call it, but not fully complete against the 40% schema coverage.

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 40%, so the description must compensate. It does clarify recipient_target ('exact IDs or a narrowed selection'), matching the anyOf branches and the most complex param. It says nothing about campaign_id, kind, threading, or requested_parent_wave_id, leaving those documented only partially in the schema.

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

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

The description names a specific verb and resource ('check ... readiness', 'final dry-run gate before bulk email') and adds that it checks only the selected recipients and returns sendability guidance. This distinguishes it from the sibling start_bulk_email (which actually sends), though it doesn't name that sibling explicitly.

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

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

It states the condition for use: this is the final gate before bulk email, requiring exact IDs or a narrowed selection. That is a clear usage context with no explicit exclusion list or named alternative, which caps it at 4.

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 the safety profile (readOnlyHint true, destructiveHint false), and the description adds genuinely non-obvious context: it is advisory only, is 'never a reservation or guaranteed price', and unlock estimates additionally require campaigns:read scope. That is real value beyond the annotations, though it says nothing about what the response contains or how a 'no capacity' result is signaled.

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, front-loaded with the core purpose and then the advisory caveat. Dense but every clause (variant list, roster limit, scope requirement, no-reservation caveat) carries information; 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 complex union-typed input with zero schema descriptions and no output schema, the description should also indicate what a result looks like (remaining capacity, boolean fit, denial reasons). It covers the inputs and the advisory caveat well but leaves the return contract entirely unstated.

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

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

Schema description coverage is 0% on a single deeply-nested oneOf parameter, so the description must carry the load. It does map the operation variants in prose and states the 1–500 unique roster ID constraint, but it omits the required campaign_id on the unlock path, the count-vs-campaign_creators target discriminator, and the exact operation discriminator strings.

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

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

States a specific verb+resource (advisory capacity check) and enumerates the four things it can check: import row count, saved-creator count, one campaign, and email unlock. An agent knows exactly what question the tool answers, though it never names a sibling or notes what it is NOT (e.g. that it does not perform 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?

'Advisory check' plus the four operation variants implies pre-flight/pre-creation usage, but the description never says explicitly when to call it versus proceeding directly, nor does it point at alternatives like check_bulk_email_readiness. Usage is inferable but not 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?

Adds genuine context beyond the annotations: completion is idempotent ('Repeat completion returns the same result'), which the agent cannot infer from readOnlyHint=false/openWorldHint=true alone. It does not say what happens when metadata verification fails, which is the remaining 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 short sentences, no waste, with the core action front-loaded and the idempotency caveat second. Nothing redundant.

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

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

No output schema exists, so the description should convey what a successful response looks like and what a failed verification means; it only covers the repeat-call case. Safety profile is covered by annotations, so the omission is moderate rather than severe.

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 the single transfer_id parameter, yet it never mentions it. The agent gets the UUID format only from the schema's pattern, with no statement of where the transfer_id comes from (presumably create_file_upload).

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

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

States a specific action: verify uploaded object metadata and accept it, i.e. the finalize step of an upload flow. This clearly distinguishes it from create_file_upload, get_file_upload and cancel_file_upload, though it never names them explicitly.

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

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

Usage is only implied by the word 'complete' — an agent can infer it must be called after create_file_upload and after the object is actually uploaded, but the description never states this ordering or any prerequisite. No when-not guidance is given.

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

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

Goes well past the destructiveHint/openWorldHint annotations by disclosing quota accounting (successful and skipped rows consume quota, errors and unprocessed rows are refunded) and by ruling out email unlocking and sending, which disambiguates it from start_email_unlock and start_bulk_email. It doesn't cover partial-failure or cancellation behavior, which matters for a destructive action.

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-loaded with the action and its precondition, then quota behavior, then side-effect exclusions. No filler; each sentence adds distinct 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?

Covers the high-risk side effects an agent needs to warn a user about, but leaves the parameters entirely undescribed and offers nothing about the outcome (no output schema exists), so an agent cannot know how to form the reference or what it gets back.

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

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

Schema description coverage is 0% across three required parameters, and the description explains none of them. The polymorphic reference union (type 'job' vs 'handoff' plus a UUID) and the const-true user_authorized have no explanation anywhere, which is exactly the gap the description should fill.

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: start the already-uploaded canonical import, gated on user approval. This clearly separates it from create_campaign_creator_import, get_campaign_creator_import, and cancel_campaign_creator_import, though those siblings are not named explicitly.

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

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

The phrase 'only after user approval' gives a real precondition and implies it runs after an upload and inspection step. It never says to use create_campaign_creator_import first, nor when to choose cancel/get instead, so the routing is only implied.

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

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

Annotations cover the safety profile (readOnlyHint=false, destructiveHint=false), so the bar is lower; the description still adds real value by disclosing that it returns source and destination IDs and that the idempotency key should be reused on retries — behavior not derivable from annotations. It stops short of saying what happens on duplicate creators, partial failures, or whether the copy is atomic.

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 the core action front-loaded and no filler. The retry/idempotency note is compact but slightly telegraphic, leaving the reader to infer that the same key prevents duplicate copies.

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, a nested oneOf target, and 0% schema coverage, the description covers the essentials of what to pass and what comes back. Gaps remain around size limits, duplicate handling, and whether the destination campaign must be in the same workspace — details an agent would need to call this confidently.

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

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

Schema description coverage is 0%, so the description must carry the load; it does map prose onto all four required params (creator IDs or selection, campaign_id as source, destination campaign, idempotency key). It omits important constraints the schema enforces silently — the 100-item cap on creator_ids, the UUID format for selection_id, and the max length on the key.

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 ("Copy ... creators ... into another campaign") and distinguishes the two supported sources: exact creator IDs or a prepared selection. It is clearly differentiated from the singular add_campaign_creator and from save_search_results_to_campaign, though it never names a sibling explicitly.

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

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

"Copy exact creator IDs or a prepared selection" implies when each mode applies, and the retry note implies the idempotency workflow. However there is no explicit routing guidance such as when to prefer this over add_campaign_creator or save_search_results_to_campaign, and no stated preconditions (e.g. that a selection must be prepared first via prepare_campaign_creator_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 state readOnlyHint=false, destructiveHint=false, and openWorldHint=true, so the description only adds that creation happens in the authenticated workspace and returns an id. It does not disclose permissions, side effects, validation behavior, defaults for optional fields, or what the created campaign contains.

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

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

The description is two short sentences and is front-loaded with the core action. It is efficient, though its brevity contributes to the missing parameter and behavioral detail rather than being optimally sized for a 10-parameter mutation tool.

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

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

For a 10-parameter create operation with no output schema and no schema field descriptions, the definition is substantially incomplete. It mentions only the returned id and one downstream sibling, leaving the optional campaign fields and creation semantics undocumented.

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

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

There are 10 parameters with 0% schema description coverage, and the description provides no parameter guidance at all. The agent is left with bare property names like brand, budget, hashtags, and amazon_product_urls without any explanation of meaning, format, or intended use.

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

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

The description states a specific verb and resource: create a campaign in the authenticated workspace. This is clear, but it does not distinguish the tool from siblings like update_campaign or list_campaigns beyond the obvious create/update/list difference.

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 useful follow-on usage hint by telling the agent to use the returned campaign id with save_search_results_to_campaign. However, it does not explain when to create a campaign versus updating an existing one, nor does it mention prerequisites or exclusions.

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

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

Annotations only declare readOnlyHint=false, destructiveHint=false, openWorldHint=true; the description adds meaningful non-obvious behavior: idempotency key stability, that browser mode is a handoff for clients that cannot upload bytes, and that direct mode returns an S3 multipart POST. It does not mention auth requirements or the 10MB ceiling, which are left to the 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?

Three tight sentences, front-loaded with the purpose and followed by the mode decision and the scope boundary. No filler, but the fragmented phrasing ('Choose browser handoff...; direct mode returns...') makes it slightly harder to parse 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 prepare/creation tool with no output schema, the description explains both modes but never says what the call returns (import id? upload URL?) or which sibling to call next, so an agent cannot fully chain the flow from this text alone.

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

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

With 0% schema description coverage, the description must carry parameter meaning. It explains the idempotency_key's purpose and the upload.mode branching semantics well, but leaves campaign_id, byte_size (10MB max), filename constraints, and checksum_sha256 format entirely to the pattern/limit metadata in the schema.

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

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

States a specific verb and resource ('Prepare a CSV/XLSX campaign import') and explicitly scopes itself against the downstream action: 'This does not start the import.' An agent can distinguish this from confirm_campaign_creator_import and get_campaign_creator_import without opening 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?

Gives explicit mode-selection guidance: 'Choose browser handoff when the client cannot upload bytes; direct mode returns an S3 multipart POST.' It also clarifies the boundary that the import is not started here. It does not name the sibling to call next (confirm_campaign_creator_import), 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?

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true. The description adds genuinely useful behavior: it does not transfer bytes itself, it returns PUT instructions and an authenticated browser handoff. It does not say whether a record is reserved, whether the upload expires, or how idempotency_key changes repeated calls.

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

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

Two sentences, front-loaded with purpose and followed by the return behavior; no filler. Given four target variants and a required idempotency key, the brevity is on the edge of under-specification rather than 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 complex upload-initiator with a nested oneOf, a replacement_confirmation const requiring user authorization, and no output schema, two sentences are thin. The description never explains the replacement/confirmation path, upload expiry, or what identifier the PUT instructions carry, all of which an agent needs before calling.

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 schema has nested objects, so the description must carry the load. It usefully enumerates the four target kinds, but says nothing about the `file` object (content_type, checksum, 500MB cap) or the required idempotency_key, leaving the highest-risk parameter undocumented in both places.

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 ('Prepare') and resource ('email attachment, contract or draft/final upload'), and the enumerated upload kinds map to the four target variants, distinguishing it from get_file_upload and complete_file_upload. 'Actor-bound' is unexplained jargon, which keeps it 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?

Usage is only implied: 'Prepare ... Return direct PUT instructions' signals this is the first step of a multi-step flow, but no sibling is named and there is no statement that complete_file_upload is the follow-up or when to cancel instead. An agent can infer the sequence from the sibling list, but the description does not do the routing.

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, destructiveHint=false and openWorldHint=true, so the write and external-visibility profile is covered structurally. The description adds real value by explaining that the idempotency key exists for safe retries. It omits the hard limits the schema imposes (max 10 fields, enumerated field_ids) and says nothing about permissions or what happens on key reuse.

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

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

Two short sentences with the core action front-loaded and no filler. Efficiency is fine; the problem is under-specification rather than verbosity.

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

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

A four-required-parameter mutation tool with 0% schema coverage, a nested field array with enumerated ids, and no output schema needs far more than two sentences. The description leaves the agent to infer field composition and payload shape entirely from the raw schema.

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

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

Schema description coverage is 0%, so the description carries the full burden and only partially delivers: it hints that idempotency_key is a 'stable retry key' and that text must be localized. The four required parameters are otherwise unmentioned — nothing explains what 'name' vs 'guide_text' mean, or how the 'fields' array should be composed.

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: 'Create a workspace form.' The scope is narrow enough that an agent can distinguish it from update_form, get_form and delete_form in the sibling list without opening 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?

There is no statement of when to use this versus update_form or create_campaign-style setup flows, and no prerequisites or permission requirements. 'Use explicit localized text for the creator audience' is content guidance, not selection guidance.

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

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

The annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is covered. The description adds real value by saying the effect is removal from future selection and that system defaults are protected. It does not say whether the delete is reversible, what happens to forms already used in campaigns, or that a 'user_authorized' confirmation is demanded.

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, no filler, and the destructive scope constraint 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?

Annotations cover the destructive profile and no output schema exists, which lowers the burden, but for a destructive mutation with two undocumented parameters the description still omits the confirmation requirement and the side effects on existing campaign 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 carry parameter meaning, and it does not. form_id is never explained, and the required confirmation field with its const 'user_authorized' is only obliquely echoed by 'explicitly approved'; an agent gets no explanation of that gate from either field.

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

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

States a specific verb+resource ('Delete ... workspace form') plus a scope qualifier ('from future selection'). That is enough to distinguish it from the CRUD siblings list_forms, get_form, create_form, and update_form, though none is named.

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 approved workspace form' and 'system defaults remain protected' imply when deletion applies (workspace forms only, not system defaults), but the description offers no explicit when-to-use rule, no prerequisites, and no alternative such as a soft-disable path.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds the polling-after-start sequencing, which is genuinely useful, but says nothing about terminal states, polling cadence, or whether the job record persists/expires.

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

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

One sentence, front-loaded with the verb and resource, with zero filler. Nothing could be removed without losing 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?

There is no output schema, so the description arguably should hint at what a 'status' contains (e.g. progress/counts/failure), which it does not. For a single-parameter read tool tied to a sibling, though, it provides enough to invoke correctly.

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

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

Schema coverage is 0% and job_id carries no format or provenance in the schema, so the description must compensate. It does partially, by stating the job_id comes from start_bulk_email, but gives no format or example for the opaque string.

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?

Specific verb ('Read') plus resource ('bulk-email job status') and it names the originating tool, start_bulk_email. It is clearly distinct from start_bulk_email and get_email_unlock_job, though it does not explicitly contrast polling of a wave via get_campaign_email_wave.

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

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

States the precondition plainly: call this after start_bulk_email returns a job_id, which tells the agent when it applies. It gives no when-not guidance or alternative for monitoring the same campaign via wave-level 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?

The annotations already declare this is a safe, read-only, open-world operation. The description only restates the read action and gives a vague data scope; it does not add meaningful behavioral context such as not-found behavior, permissions, or response characteristics.

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

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

The single sentence is concise, front-loaded, and free of filler. Its brevity is appropriate structurally, though the content is under-specified for the tool's needs.

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

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

With no output schema and no parameter documentation, the description should do more to explain what 'settings and status' includes and how the campaign_id identifies the target. It leaves the agent with too little context for reliable 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 description does not mention campaign_id at all, despite schema description coverage being 0%. The parameter name is self-explanatory, but the description fails to compensate for the missing schema 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 states a specific read operation on a campaign and indicates the data scope as settings and status. It is clear what the tool does, but it does not distinguish itself from siblings such as list_campaigns or the more specific get_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?

Usage is implied: retrieve one campaign's settings and status. However, there is no explicit guidance on when to use this instead of list_campaigns, update_campaign, or subresource tools like get_campaign_performance.

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

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

The annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context about progress, quota accounting, and bounded row issues, but does not explain permissions, row-bound behavior, or pagination.

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 definition is a single dense sentence with the operation and data scope front-loaded. 'Bounded row issues' is slightly opaque, but there is no wasted framing.

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?

Because there is no output schema, the description reasonably lists the main data categories returned. However, it omits the role of campaign_id and does not clearly position this status tool against the results-oriented sibling, leaving some selection 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% for two required parameters. The description helpfully implies the reference can be a job or handoff identifier and should be reused, but it says nothing about campaign_id and does not clarify the reference object's required type/id structure beyond what the schema itself enforces.

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 read operation over spreadsheet-import status, quota accounting, and row issues. It clearly identifies the resource but does not explicitly distinguish this tool from the nearby get_campaign_creator_import_results sibling.

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

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

The phrase 'using the same job or handoff reference' implies this is a follow-up call after starting an import, but it gives no explicit when-to-use guidance or contrast with get_campaign_creator_import_results, confirm, or cancel.

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 the safety profile (readOnly, non-destructive, openWorld), so the description earns credit for adding real behavior: result generation may still be pending after completion, and files expire after seven days. It does not say what error/response occurs when the import is non-terminal or the file has already expired, which would complete the picture.

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, no filler, with the terminal-import precondition and the expiry constraint front-loaded. Every clause carries operational weight (pending generation, reference retention, seven-day lifetime).

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-param read tool with read-only annotations and no output schema, the description covers preconditions, the pending-generation quirk, and expiry. The remaining gap is how the result is delivered (URL vs. content) and behavior on non-terminal or expired imports.

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 `reference` parameter is a non-trivial oneOf over job vs. handoff objects, which the description never addresses. "Preserve the reference" hints at provenance but adds no meaning about the required `{type, id}` shape or the `campaign_id` pairing, so it fails to compensate for the coverage gap.

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

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

States a specific verb and resource ("Get the result CSV for a terminal import") and scopes it to terminal imports, which differentiates it from get_campaign_creator_import (status) in effect, though the sibling is never named. An agent can tell what it retrieves without opening the schema.

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

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

Gives a clear precondition (import must be terminal), an operational directive (preserve the reference, never reimport to get results), and repeatedly warns against the wrong recovery path. It stops short of explicitly naming get_campaign_creator_import as the tool to poll while the import is still running.

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, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds meaningful context beyond annotations by noting that the result includes delivery uncertainty and cancellation availability, though it does not explain auth, rate limits, or error behavior.

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

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

The description is a single front-loaded sentence with no wasted words. It states the core action and adds relevant return-context details efficiently.

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 tool with one parameter and no output schema, the description covers the basic purpose and hints at returned fields. However, without an output schema, it does not explain the wave object contents, identifier source, or failure behavior, leaving some 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?

There is one required wave_id parameter, but the schema description coverage is 0% and the description adds no parameter-level meaning beyond implying a single wave is read. The schema does constrain wave_id as a UUID, but the description does not compensate for the lack of schema descriptions.

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

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

The description uses a specific verb, "Read", and a specific resource, "one campaign email wave", making the single-item scope clear against the list endpoint. It adds useful detail about delivery uncertainty and cancellation availability, but does not explicitly name siblings like list_campaign_email_waves or cancel_campaign_email_wave.

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 what the tool does but gives no explicit guidance on when to use it versus list_campaign_email_waves, cancel_campaign_email_wave, or retry_campaign_email_wave. An agent can infer it is for fetching one wave by ID, but the description does not say so or provide exclusions.

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/openWorld/non-destructive. The description adds real value with 'short-lived' and 'authorized', signaling expiration and permission checks. However it never says what the returned download actually is (URL? token? expiry window?) or whether it can be reused, which matters for a link-minting 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?

One tightly written sentence with the key qualifier ('short-lived authorized') front-loaded. It is efficient but arguably under-sized given three undocumented required parameters.

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

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

There is no output schema, and the description doesn't explain what the agent receives back (a URL, a token, an expiry) or how long 'short-lived' is. Combined with 0% parameter documentation across three required params, an agent cannot reliably construct the call or interpret the result from this description alone.

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

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

Schema description coverage is 0%, so the description must compensate, and it only partially does: 'contract or selected draft/final file' loosely maps to the file oneOf discriminator. The two required integer parameters (campaign_id, campaign_creator_id) and their relationship are entirely undocumented, and the required file_id for draft/final is never mentioned.

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

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

States a specific verb+resource ('Return a short-lived authorized download') and names the file variants (contract, draft/final), which is genuinely informative. It doesn't differentiate itself from nearby file tools like list_campaign_creator_files or get_message_attachment_download, 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?

Use is implied — call it when you need a download for a campaign contract or a selected draft/final file. There is no explicit when-not guidance, no mention of prerequisites (e.g. that the file must already exist or that campaign_creator_id must belong to the campaign), and no naming of alternatives.

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

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

Annotations already establish readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds genuine behavioral context beyond that: the window is interpreted as explicit UTC, and returned figures distinguish lifetime metrics from missing-history coverage, which tells an agent how to interpret the payload.

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

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

A single dense sentence with zero filler; the windowing constraint and the data-coverage caveat are both front-loaded and each clause carries information.

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

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

With no output schema, the description usefully sketches the return structure (totals plus separately labeled lifetime and missing-history metrics). However, for a four-parameter read tool with 0% schema coverage, the silence on granularity and campaign_id leaves the agent guessing.

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

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

Schema description coverage is 0%, so the description must carry the burden of explaining all four parameters. It clarifies the UTC interpretation of the start/end window, but says nothing about campaign_id or the 'granularity' enum (day/week/month, default day), leaving a meaningful bucketing control completely unexplained.

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 ('Read') and resource ('campaign totals') scoped to a campaign over an explicit window, which is enough to separate it from per-creator or per-video performance siblings. It never names an alternative tool, so differentiation is inferred rather than explicit.

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

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

The description gives no when-to-use guidance, no exclusions, and does not point to alternatives such as get_campaign_revenue or list_campaign_creator_performance, even though the sibling list contains several closely overlapping performance reads. The only steering is the requirement of an explicit time window.

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 this a safe read (readOnlyHint=true, destructiveHint=false), so safety is covered. The description earns credit for adding that only 'finalized' revenue is returned within a bounded window, which tells the agent results may be incomplete for recent dates. But it says nothing about pagination limits, currency conversion behavior, or what 'opt-in' details actually cost (latency, limits).

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, zero filler, with the core capability front-loaded and the opt-in caveat immediately after. Nothing to trim; only shortcoming is that the brevity leaves gaps noted elsewhere.

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

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

For a 7-parameter read tool with no output schema and zero schema descriptions, this description is thinner than ideal — it omits return shape, pagination semantics, and the meaning of most optional flags. It does convey scope (bounded, finalized, by provider and native currency), which is the essential framing, but not enough for confident invocation of optional parameters.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate and largely doesn't. It vaguely gestures at 'products are opt-in' (plausibly include_products/product_limit/product_offset) and 'details' (unclear whether that means include_points), but never explains product_limit/product_offset pagination or what include_points adds. An agent must guess at nearly every optional parameter.

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

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

States a specific verb+resource ('Read ... campaign revenue') with meaningful qualifiers that separate it from sibling analytics tools like get_campaign_performance: 'bounded' (date-range scoped) and 'finalized' (settled vs. estimated) revenue, reported 'by provider and native currency'. The direction is clear, though it never names which sibling it differs from.

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?

'Details and products are opt-in' gives a hint that extra payloads must be requested, but it doesn't say when an agent should pull revenue here versus via get_campaign_performance, nor any prerequisites (e.g., revenue availability/finalization timing). Usage is implied rather than stated.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds real value with 'cumulative' (values accumulate rather than per-period deltas) and 'bounded' (range constraints), but says nothing about range limits, data freshness, or what a sample contains.

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

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

A single front-loaded sentence with no filler; the key qualifiers (bounded, cumulative, one video) come before any detail. It is efficient, though the terseness is part of why behavioral and parameter gaps remain.

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 5-parameter tool with 0% schema descriptions and no output schema, the definition covers the core concept and, via annotations, the safety profile. It still leaves an agent guessing about return shape, metric content, and parameter pairing, so it is adequate but not 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%, so the description must compensate. It conveys the concepts behind granularity (daily/weekly/monthly) and implies a date-bounded query scoped to one campaign/video pair, but leaves unexplained the relationship between campaign_id and video_id, date/timezone format, and that granularity defaults to 'day'.

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 (read), resource (campaign video history), and scope: bounded daily/weekly/monthly cumulative samples for one tracked video. It is clear what the tool returns, but it never distinguishes itself from related siblings like list_campaign_video_performance or get_campaign_performance, leaving the agent to infer the history-vs-current split.

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

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

The phrase 'bounded ... for one tracked campaign video' implies usage (time-series history for a single video within a date range), but there is no explicit when-to-use, when-not-to-use, or named alternative such as list_campaign_video_performance. Guidance is implied rather than stated.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description's 'Read' adds nothing. Beyond that it discloses nothing about the return shape (aggregate counts keyed by what?), whether the campaign_id scopes everything, or any cost/pagination behavior — for an openWorldHint tool this is a meaningful gap.

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

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

A single front-loaded sentence with no padding, which is structurally good. However the brevity comes at the cost of comprehensibility — 'the roster' and 'workflow counts' are compressed to the point of ambiguity rather than genuine concision.

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 7 parameters, zero schema descriptions, no output schema, and no annotations explaining results, the description should explain what a 'workflow count' contains and how campaign_id interacts with the filters. It does neither, leaving the agent unable to predict the response or understand the required parameter.

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

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

Schema description coverage is 0% across 7 parameters, so the description must carry the load, but it only name-drops five of them (platform, country, source_type, outreach_stage, search) without explaining formats or defaults. The required campaign_id and the has_video flag are not mentioned at all, and the enum values are left entirely to the schema.

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

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

States a specific verb ('Read') and resource ('workflow counts'), which distinguishes it from mutation siblings, but 'workflow counts' and 'the roster' are undefined jargon — an agent cannot tell what is being counted or which tool produces the roster. The scoping phrase 'same platform, country, source, stage and search context' gestures at the resource but never names it.

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

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

The phrase 'as the roster' implies this tool is meant to accompany a roster-listing call, but no sibling is named (list_campaign_creators is the likely one) and there is no explicit when-to-use or when-not-to-use guidance. No alternative tools for obtaining counts are mentioned.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that recent content retrieval is optional and bounded, but it does not mention permissions, rate limits, or the shape of the response.

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

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

Two short sentences, front-loaded with the core action and scope. No wasted words, and the optional recent-content behavior is stated compactly.

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 a read operation with no output schema, and annotations cover its safety profile. However, the nested selector offers creator_id, origin_id, and username, and the description only mentions ID and username, leaving origin_id and the platform constraint underexplained.

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

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

Schema description coverage is only 33%, so the description needs to compensate for parameter meaning. It does clarify that the selector can use a stable ID or username and that recent content is optional and bounded, but it omits the origin_id selector variant and does not explain the platform enum.

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

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

The description states a specific verb and resource: read a known creator, with scope limited to stable ID or username. The word "known" helps distinguish it from the sibling search_creators tool, though it does not name that alternative explicitly.

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

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

Usage is implied: use this when you already have a stable creator ID or username. The description mentions that recent content is optional and bounded, but it does not explicitly say when to prefer get_creator over search_creators or when not to use it.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true, so the safety profile is covered. The description adds valuable behavior beyond that: it uses the status value 'not_in_catalog' as a decision signal and names the remediation tool. It stops short of enumerating other possible status values, so it isn't fully exhaustive.

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

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

Two sentences, front-loaded with the purpose and followed by the routing rule. No filler, and every clause carries decision-relevant information.

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

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

No output schema exists, so the description must carry the status semantics, and it does partially by exposing 'not_in_catalog' and its follow-up action. It leaves the full set of possible status values unstated, but an agent can still call and route 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% and both parameters (platform enum, username handle format) are documented in the schema. The description adds no syntax or format detail beyond that, so the baseline 3 applies.

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

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

States a specific verb (check) and resource (creator catalog status) plus the downstream purpose: whether the creator can seed a reference/lookalike search. This distinguishes it clearly from siblings like search_creators and request_creator_catalog_enrichment.

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 'Call this before a reference search' and gives the branch condition: 'not_in_catalog means request_creator_catalog_enrichment first.' The when-to-use and the named alternative are both present.

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, openWorldHint=true, and destructiveHint=false, so safety is covered. The description adds useful context with 'durable' and the sequencing before readiness, but does not describe return states, latency, or permission requirements.

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

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

A single front-loaded sentence with no wasted words. The purpose and timing constraint are immediately clear.

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

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

There is no output schema, so the description could usefully mention what job status values mean or what success/failure looks like. It covers the prerequisite context but leaves return semantics and job-state handling implicit.

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 sole required parameter, job_id, beyond what the tool name implies. The schema supplies UUID format and pattern, but there is no semantic detail about where job_id comes from or how to obtain it.

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

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

States a specific verb ('Read') and resource ('durable campaign email-unlock job status'), and clarifies its role relative to bulk-email readiness. It does not explicitly distinguish itself from sibling get_bulk_email_job, but the resource is clear enough to identify the correct 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?

Provides clear timing guidance ('before checking bulk-email readiness'), which helps an agent place this call in a workflow. It does not name alternatives or exclusions, but the context is sufficiently clear for a prerequisite status check.

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, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds useful scoping ('same actor and workspace') and notes a refresh behavior, but it does not explain whether refreshing invalidates prior instructions or how errors/permissions behave.

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 definition is a single efficient sentence with the main action front-loaded. It is appropriately sized for a simple read tool, though 'refresh pending transfer instructions' is slightly ambiguous.

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 low-complexity read tool with annotations covering safety and no output schema, the description is adequate but incomplete: it does not explain what the returned upload status contains or what 'refreshing' transfer instructions actually yields.

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 never mentions transfer_id directly. However, with only one required UUID parameter whose name is self-explanatory, and the description's 'same actor and workspace' scoping, the gap is less severe than it would be for a multi-parameter tool.

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

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

The description states a specific resource (file upload) and two read actions (read upload status, refresh pending transfer instructions), scoped to the same actor and workspace. It is clear enough to distinguish from create/complete/cancel siblings, though it does not name them explicitly.

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

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

Usage is implied by the two stated actions—check status or refresh transfer instructions—but there is no explicit guidance on when to prefer this tool over complete_file_upload, cancel_file_upload, or create_file_upload. No exclusions or alternatives are named.

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, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds that the response includes the template plus its editable fields, which is modestly useful context about what comes back, but it says nothing about failure behavior for invalid or deleted form IDs.

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

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

A single short sentence with the resource named up front and zero filler. It is efficient, though its brevity is closer to terseness than to well-structured completeness.

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

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

For a one-parameter read tool whose annotations cover the safety profile, this is close to adequate; the notable omission is that there is no output schema and the description gives only a phrase ('editable fields') about the return shape. An agent could call it, but with limited expectations about the payload.

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 full burden of explaining the single parameter — and it never mentions form_id, its integer type, or where to obtain a valid ID. It is only inferable from the tool name and typical REST conventions, which is a real gap given the schema documents nothing.

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 ('Read') and resource ('one form template') and scopes it to a single record, which implicitly separates it from the sibling list_forms. No sibling is named explicitly, so it stops short of full 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?

'Read one form template' implies retrieval of an existing form by identifier, which is sufficient to select it over list_forms in obvious cases. However, there are no explicit when-to-use/when-not statements, no prerequisites, and no mention of the other form siblings (create_form, update_form, delete_form).

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, destructiveHint=false, and openWorldHint=true, so the safety profile is covered and the description is not required to re-state it. The description adds useful content scoping (what topics the guide covers) but says nothing about response format, size, or whether the guide is static versus contextual to the calling workspace.

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

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

A single front-loaded sentence that names the deliverable and its contents with zero filler. There is no sentence that could be removed without losing 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?

With no output schema and no parameters, the description carries the burden of explaining what comes back. It enumerates the three content sections, which is helpful, but leaves the return shape (structured data vs. prose/markdown) and any guidance on acting on the guide unstated. Adequate but with a clear gap for a tool whose entire value is its output.

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 takes zero parameters, so the baseline is 4; there is no parameter semantics to explain and the description correctly avoids inventing any. Nothing in the description misrepresents the empty input contract.

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 ('Return') and a specific resource (the Hyperstar workflow guide), then enumerates its three content sections: workflow sequence, discovery resources, and send-safety notes. This is clearly distinguishable from every sibling, which perform concrete operations rather than returning guidance. It loses the top mark only because it never explicitly frames itself as the onboarding/preamble step relative to those 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?

Usage is implied rather than stated: 'recommended Hyperstar workflow sequence' and 'send-safety notes' hint that an agent should consult this before running campaign/email operations, but there is no explicit 'call this first', no when-not condition, and no named alternative. An agent must infer the ordering itself.

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, destructiveHint=false and openWorldHint=true, so safety is covered. The description adds essentially nothing beyond the name: it does not say what counts are returned, whether counts respect all supplied filters, or anything about openWorld behavior or cost. Some credit only for framing the output as aggregates rather than records.

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

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

A single front-loaded sentence with no wasted words, but its brevity reflects under-specification rather than efficiency given the 14-parameter surface.

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 14-parameter aggregation tool with no output schema, the description should at minimum explain that counts are computed over the filter set and how the filters intersect. None of that is present, leaving the agent unable to call it confidently beyond passing no arguments.

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?

Fourteen parameters with 0% schema description coverage and no parameter mention in the description. Filter semantics such as how search, attention, actionable_only, or the date-range pair combine are left entirely undocumented, so nothing compensates for the coverage gap.

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

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

States a specific verb ("Read aggregate counts") and resource ("Hyperstar inbox filters"), which distinguishes it from list_inbox_threads or get_inbox_thread_messages that return records rather than counts. It stops short of naming a sibling or contrast, so it is clear rather than fully differentiating.

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?

"to summarize inbox state" implies the use case (dashboard/summary views rather than fetching threads), but there is no explicit when-to-use versus list_inbox_threads, no note about cost versus listing, and no exclusions.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description confirms the read is over 'full message history' but says nothing about ordering, truncation, or volume limits on long threads.

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

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

A single front-loaded sentence with zero filler; the scope and the motivating decision both land immediately.

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 read with no output schema, the description is directionally adequate but leaves the platform enum, thread_id sourcing, and rough return shape (message fields, ordering) unexplained — gaps that matter for a first call.

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

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

Schema description coverage is 0% for both parameters. The description never explains what 'platform' means (the enum value 'buyer' is especially opaque) or what a thread_id refers to or where to obtain it, so it does not compensate for the schema 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+resource with scope: 'Read full message history for one Hyperstar inbox thread.' The phrase 'one ... thread' implicitly separates it from list_inbox_threads, though no sibling is named explicitly.

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

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

'before deciding whether to reply' gives a concrete decision point that routes the agent here ahead of send_inbox_reply. It does not name alternatives or exclusions, 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=true and destructiveHint=false, so the safety profile is covered. The description adds genuinely new behavioral context: the call 'authorizes' (implying permission scoping) and returns a 'short-lived' URL, warning the agent the result expires and must be used promptly. It stops short of describing failure modes for missing attachments.

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

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

One sentence, front-loaded with the action and ending on the returned artifact. 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 four required, entirely undescribed parameters and no output schema, the description should at minimum explain how the identifiers nest and what the URL response contains. It gives only the URL and its expiring nature, which is insufficient for a tool that must be invoked with a precise four-part addressing tuple.

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

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

Schema description coverage is 0% for four required parameters, and the description supplies no compensating detail. It never mentions that platform, thread_id, and message_id form a hierarchy required to locate the attachment, nor what attachment_id refers to, leaving the schema as the only (undocumented) 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 states a specific verb pair and resource: authorizing an inbox attachment and returning a download URL. That is clear and distinguishable from read-only listing tools like get_inbox_thread_messages, though it never names the analogous sibling get_campaign_file_download to draw the boundary explicitly.

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

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

Usage is only implied: the agent can infer this is the step to take when it needs to actually fetch attachment bytes. There is no explicit guidance on when this is needed versus when listing messages suffices, nor any mention of prerequisites.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds useful output-shape context (compact summaries by default vs raw detail pages) but says nothing about pagination behaviour, termination, or result counts, which are the real behavioral questions for a paging 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?

One sentence plus a qualifier, front-loaded with the core action and the default behaviour. No filler. The phrase 'raw detail-on-demand pages' is slightly jargon-heavy but still compact.

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

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

There is no output schema, so the description should clarify what comes back and how paging terminates. It hints at result granularity but omits total counts, exhaustion signals, or max limit context, leaving real gaps for a 4-parameter paging 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 only 25%, with only search_id documented. The description compensates partially by explaining detail_level's default and intent, but limit and offset are left to the schema with no semantics beyond the verb 'page through'. Given the coverage gap, this does not fully compensate.

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: 'Page through an existing creator search.' The word 'existing' implicitly differentiates it from search_creators, which creates the search, though the sibling is not named. An agent can tell what it retrieves without opening the schema.

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

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

Gives a clear conditional rule for detail_level: default to compact summaries, use 'full' only for raw detail-on-demand pages. It doesn't state explicitly that search_id comes from search_creators or when to avoid the tool, but the operating context is clear enough to call it correctly.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value beyond that by naming the required permission scope and clarifying that no balances are initialized and no units reserved, i.e. genuinely side-effect free.

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, both front-loaded with the useful information (what is read, then auth/side-effect constraints). No filler, no redundancy with the title.

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

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

With no parameters and no output schema, the description carries the burden of telling the agent what comes back, and it does so by enumerating credits, upload quota, and creator/campaign capacity. The only gap is the unresolved overlap with check_operation_capacity.

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 takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No misleading parameter claims are made.

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 concrete verbs and resources: reads credits, upload quota, and occupied creator/campaign capacity. An agent immediately knows it retrieves usage meters. It does not, however, distinguish itself from the sibling check_operation_capacity, which also sounds capacity-related.

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

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

The description gives an auth prerequisite ("Requires usage:read") and a scope exclusion ("does not initialize balances or reserve units"), which implies when it's appropriate. But it never names an alternative or states when to prefer check_operation_capacity over this tool, so routing between the two is left to inference.

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

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

Annotations already establish readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so safety is covered. The description adds meaningful behavioral context beyond that: this is a preflight/identity probe that reveals scopes and capabilities, implying auth preconditions gate other tools. It does not document the response shape, but the preflight intent is the key disclosure.

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

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

A single front-loaded sentence naming the verb, the object, and the timing; no filler or redundant restatement of the title.

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

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

With no params and a simple read-only operation, a one-liner is nearly sufficient, and it enumerates what is inspected (principal, workspace, scopes, capabilities). Since there is no output schema, a brief note on what the response returns would close the last gap.

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

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

Zero parameters, so the baseline is 4 per the rubric. The description correctly implies no inputs are needed by framing the tool as a pure inspection of the caller's own context.

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

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

Specific verb ("Inspect") plus concrete resource ("authenticated Hyperstar principal, workspace, scopes, and capabilities"), which cleanly separates it from all the campaign/creator/inbox workflow siblings. An agent can identify this as the identity/context tool without opening 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?

"before running workflow tools" gives a clear timing/precondition for calling it, which is actionable guidance rather than a bare description. It stops short of naming explicit alternatives or when-not-to-use cases (e.g., that it is not needed for repeated calls within a session).

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds that only metadata is returned (not file content) and that results are scoped to a single creator, which is useful context, but it says nothing about pagination behavior or the shape of results.

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

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

One front-loaded sentence with no filler or repetition. It is efficient, though the brevity edges toward under-specification for a 4-parameter tool.

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

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

With no output schema, zero schema coverage on four parameters, and pagination unmentioned, the description is too thin for the tool's complexity. An agent cannot tell what fields come back or how to page through results.

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

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

Schema description coverage is 0% across 4 parameters, so the description must compensate and largely does not. 'One creator' loosely maps to campaign_creator_id, but campaign_id, limit and offset are never explained, leaving pagination semantics undocumented anywhere.

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?

Specific verb (read) plus a concrete resource (contract and draft/final review file metadata) and a scope (one creator), which separates it from download/remove file siblings. It is slightly at odds with the tool name 'list' since no listing/pagination behavior is implied.

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

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

No statement of when to use this rather than get_campaign_file_download, get_campaign_creator_import_results, or other file siblings, and no prerequisites. The agent must infer usage purely from the tool name.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so safety is covered. The description adds that results rank creators by tracked-video period metrics, but it omits pagination behavior, result ordering details beyond the schema, and any caveats about campaign scope.

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

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

Two tight sentences with no filler. The primary purpose is front-loaded, and the contrasting clarification follows immediately.

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

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

For a 7-parameter, no-output-schema tool, the description is too thin. It should clarify pagination, how campaign_id scopes results, date period semantics, and what performance ranking is returned, rather than only distinguishing campaign metrics from creator profile statistics.

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

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

Schema description coverage is 0% for 7 parameters. The description only indirectly implies period metrics (start/end) and metric ranking (sort_by), while leaving campaign_id, limit, offset, granularity, and date-format expectations undocumented.

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

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

The description states a specific action ('Rank') and resource ('campaign creators') scoped to 'tracked-video period metrics.' It also distinguishes itself from creator profile statistics, though it does not explicitly name siblings such as list_campaign_creators or get_creator.

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 sentence 'These are campaign metrics, not creator profile statistics' gives useful contrast and implies when to choose this over profile-oriented tools. However, it does not explicitly state when to use this versus analogous campaign performance tools or clarify required campaign/date context.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds only a downstream workflow prerequisite (check_bulk_email_readiness before bulk send); it says nothing about pagination behavior, default page size, or total counts, which matter for a list endpoint capped at 2000.

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

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

Two short sentences with the account of what the tool does front-loaded. The second sentence is a bit tangential to this tool's own operation, but it is short and actionable rather than 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 10-parameter, unfiltered-in-description list tool with no output schema and near-zero schema coverage, the description is far too thin. It leaves filter semantics, pagination defaults, and result shape entirely undisclosed.

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?

10 parameters with only 10% schema description coverage: only campaign_id is documented (and that in the schema, not the description). The description never mentions the rich filtering surface — search, country, platform, has_video, source_type, outreach_stage, workflow_filter — nor limit/offset semantics, so the agent must infer all of it from bare schema types and enums.

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?

Specific verb and resource: 'List creators saved on a campaign roster.' The phrase 'saved on a campaign roster' implicitly distinguishes this from the global search_creators sibling, though it never names that sibling or explicitly contrasts the two.

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 roster framing implies when the tool applies, and the second sentence chains it to a downstream bulk-email workflow via check_bulk_email_readiness. But it gives no explicit when-not guidance and never contrasts with search_creators, get_campaign, or list_campaign_creator_performance.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds two useful behavioral facts beyond that: results are bounded, and the payload includes delivery state counts. It does not disclose pagination, ordering, or default page size behavior, so it adds moderate rather than rich 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?

A single front-loaded sentence with no filler or redundancy. It is efficient, though the extreme terseness is arguably the source of the missing usage and parameter detail rather than a virtue in itself.

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 three-parameter read-only list tool with no output schema and covered safety annotations, the description gives the essential gist plus a hint at return contents (delivery state counts). It is still short of complete: no guidance on paging through results, result ordering, or when to prefer this over the singular get_campaign_email_wave.

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 full burden. It alludes to the state enum ('active/recent') and boundedness (limit), but never explains the combined 'active,recent' value, the 1-100 limit range, the default of 20, or what campaign_id identifies. Partial compensation only.

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 (read/list) plus the resource (campaign email waves) and narrows scope to 'bounded active/recent'. This distinguishes it reasonably from cancel_campaign_email_wave and retry_campaign_email_wave, but it never explicitly contrasts with the singular sibling get_campaign_email_wave, leaving the list-vs-single distinction to inference from 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?

There is no explicit when-to-use or when-not-to-use guidance, and no sibling is named as an alternative. The phrase 'bounded active/recent' hints at the intended scope, but an agent must guess whether to call this or get_campaign_email_wave for a single wave.

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, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds the useful 'authenticated workspace' scoping constraint but says nothing about result volume, whether limit/offset are honored, or what 'sync' does. With annotations carrying the safety burden, a 3 is appropriate.

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

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

One sentence, front-loaded with the verb and resource, with the purpose clause trailing rather than leading. No filler or restatement of the title.

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

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

There is no output schema, four parameters are undocumented in both schema and description, and pagination semantics for limit/offset are unexplained. The description covers why to call the tool but leaves an agent guessing how to call it correctly, which is inadequate for a four-parameter listing tool.

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

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

Schema description coverage is 0% and none of the four parameters (sync, limit, offset, status) gets a single word of explanation in the description. The only identifier mentioned, campaign_id, is not a parameter at all but a field in the result. The description therefore does nothing to compensate for the documentation 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 and resource ('List campaigns') and scopes it to 'the authenticated workspace', which separates it from both list_workspaces and the single-campaign get_campaign. It also names the downstream use (choosing a campaign_id), so the agent understands the output's role. It does not explicitly contrast itself with siblings that also enumerate campaigns, keeping it at 4 rather than 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?

Gives a concrete when-to-use: before save_search_results_to_campaign, so the agent knows this is a prerequisite lookup. It stops short of saying when NOT to use it (e.g., when a campaign_id is already known and get_campaign should be called instead), so it is clear context without exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds one genuine behavioral detail (pagination via next_offset), but that token isn't among the schema parameters and no other behavior (ranking tie-breaking, empty results, permission scope) 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 padding, and the core behavior is front-loaded. The second sentence is useful but references a token not present in the schema, which costs a little clarity.

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

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

For a 7-parameter read tool with no output schema, the description should at least characterize the returned metrics and the paging model. It hints at paging but leaves the metric set, ranking semantics, and all filtering parameters unexplained.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate and largely fails to. It says nothing about start/end time windows, sort_by, granularity, or limit/offset bounds, and 'next_offset' does not even match the offset parameter name in the schema.

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

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

The verb 'Rank' and resource 'tracked videos by observed period metrics' give a rough purpose, but the tool's actual scope (campaign-scoped video performance) is only inferable from the name. It doesn't differentiate itself from close siblings like list_campaign_creator_performance or get_campaign_video_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?

No indication of when to use this versus list_campaign_creator_performance, get_campaign_performance, or get_campaign_video_history, and no prerequisites or exclusions. The agent must guess based on tool names alone.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered; the description's useful addition is that results span both system-provided and workspace-owned forms. It says nothing about pagination behavior or how large the result set can be, so it adds only modest context beyond the annotations.

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

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

A single front-loaded sentence with no filler. Its brevity is appropriate for a simple list tool, though the space saved was not reinvested in paging or scoping 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 no-required-param list tool with annotations and no output schema, this is minimally adequate. Gaps remain around pagination, what distinguishes system forms from workspace forms in the response, and whether the list is filtered by anything implied by 'for a send'.

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

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

Schema description coverage is 0% for two parameters (limit, offset) whose defaults, maximums, and pagination semantics are undocumented anywhere. The description does not compensate — it never mentions paging, result caps, or how to retrieve more than the first page.

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?

Specific verb and resource: lists forms, scoped to 'system and workspace' and 'for a send'. That distinguishes it from get_form/create_form/update_form/delete_form by operation type, though the description never names those siblings explicitly.

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

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

'for a send' implies the scenario (picking a form to attach to an outbound send), but there is no explicit when-to-use vs when-not, no mention of how it relates to get_form for detail lookup, and no stated prerequisites.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description usefully discloses that results are thread *summaries* rather than message bodies, which explains why get_inbox_thread_messages exists as a follow-up. It says nothing about pagination defaults, result ordering, or caps (limit max 500) that affect how an agent iterates.

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, no filler, with the core purpose front-loaded before the workflow instruction. Nothing is redundant with the title or annotations.

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

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

For a tool with 18 optional parameters, no output schema, and zero schema descriptions, two sentences are not enough — the agent gets no guidance on filter combinations, pagination strategy, or what a 'thread summary' contains. The safety side is complete thanks to annotations, but the calling side is under-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?

Schema description coverage is 0% across 18 parameters, so the description carries the full burden and names none of them. It only says 'filters for triage', giving no hint about snoozed/archived/attention/actionable_only/label_ids/platforms or date-range semantics, leaving the agent to infer behavior from bare parameter names.

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 ('List Hyperstar inbox thread summaries') and adds scope ('with filters for triage'), which is clearer than the bare name. It does not distinguish itself from the closely related sibling get_inbox_aggregates, which an agent could easily confuse with a summary-listing call.

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 line 'Call get_inbox_thread_messages before drafting replies' gives one explicit sequencing rule and names the sibling to use next. However, it never says when to use this tool versus get_inbox_aggregates, nor which of the many filter modes is appropriate for which triage scenario.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds genuinely non-obvious behavior: results depend on credential type — a hosted all-workspace grant yields an organization_id to reuse as workspace_id, while an API key is bound to a single workspace. That credential-conditional shape is exactly what an agent needs before calling.

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

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

Two sentences, no filler, and the identifying statement comes first with the credential nuance immediately after. The second sentence is dense but every clause carries information an agent would otherwise have to guess.

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-argument, no-output-schema list tool, the description covers scope and the credential-dependent result cardinality, which is the main ambiguity. It stops short of naming the fields a workspace record contains (id, name, organization), a minor gap given no output schema exists to declare them.

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

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

With zero parameters the baseline is 4, and the description does not squander it: it explains how the output is consumed downstream (organization_id used as workspace_id), which gives meaning to a value the schema cannot express.

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

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

The description gives a specific verb and resource ('List Hyperstar workspaces') plus the important qualifier 'available to the current credential', which tells the agent the scope is auth-dependent rather than global. It is clear enough to select without opening the schema, though it does not explicitly contrast itself with nearby tools like hyperstar_whoami or get_workspace_usage.

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

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

Usage is implied rather than stated: the mention of passing organization_id as workspace_id 'on later calls' signals this is a discovery step that feeds downstream calls. There is no explicit 'use this when...' or exclusion of alternatives such as hyperstar_whoami, so the agent must infer the placement.

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, destructiveHint=false, and openWorldHint=true, so the safety profile is mostly covered. The description adds a useful 100-item cap and the review-before-mutation intent. It does not disclose whether calling this overwrites an existing prepared selection, where the review state lives, or what side effect occurs for an operation that is non-readonly.

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

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

Two short sentences, front-loaded with the action and item limit. There is no filler, and the key usage cue about narrowing before copy or removal is placed immediately after the core action.

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

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

The tool has two required parameters, a nested filter object with six fields and enums, 0% schema description coverage, no output schema, and a non-readonly annotation. The description covers only the high-level action and a cap, leaving the filter behavior, campaign scoping, return/selection identity, and side-effect semantics undocumented.

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

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

Schema description coverage is 0%, and the description never explains campaign_id or any of the nested filter fields such as workflow_filter, source_type, platform, or search. 'matching creator IDs' implies filter semantics, but it does not add meaning beyond the bare schema key names.

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: saving up to 100 matching creator IDs for review. The phrase 'before copy or removal' helps distinguish it from sibling mutation tools like copy_campaign_creators and remove_campaign_creators. It is slightly unclear whether the selection is persisted or just prepared, but the core purpose is understandable.

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?

'before copy or removal' and 'Narrow larger selections' imply when to use the tool: as a precursor to bulk copy/removal and when a selection is too broad. However, it does not name alternatives explicitly, nor does it state when not to use it versus list_campaign_creators, search_creators, or save_search_results_to_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?

Annotations already declare destructiveHint=true and openWorldHint=true, so the safety profile is carried structurally. The description adds useful operational context — that an authorization confirmation and a stable idempotency key are mandatory — but that requirement is also visible in the schema const/pattern, and it never says what actually happens to removed creators, whether the operation is reversible, or how a retry replays.

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, no filler, and the scope statement comes first with the preconditions second. Every sentence carries operational weight.

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 destructive mutation with four undocumented parameters, no output schema, and nested oneOf branching in the target. The description does not cover consequences (are creators detached from the campaign or deleted outright?), the 100-id cap, whether a snapshot selection is consumed on use, or the failure/retry semantics, leaving an agent under-informed before a write.

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

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

Schema description coverage is 0% across all four required parameters, so the description must compensate and largely does not. It hints at the two target modes ('creator IDs or a prepared selection') but says nothing about campaign_id, the max-100 id limit, the confirmation semantics, or why the idempotency key must be stable across retries.

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 ('Remove ... creator IDs or a prepared selection from a campaign') and names both supported target modes, which clearly separates it from add_campaign_creator and update_campaign_creator. It stops short of explicitly naming those siblings as the counterpoint, so it is clear but not maximally differentiated.

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

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

The description states preconditions ('Requires confirmation and a stable retry key') but gives no guidance on when to choose the ids mode versus the snapshot mode, and never points to prepare_campaign_creator_selection as the source of a selection_id. Usage is implied by the schema shape rather than explained.

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, readOnlyHint=false, openWorldHint=true, so the risk profile is known. The description adds only vague hints ('explicitly approved', 'exact') but says nothing about irreversibility, what happens to the underlying file storage, or error behavior on nonexistent/mismatched files.

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

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

A single compact sentence with no filler. Efficient, though its brevity is partly the source of the gaps elsewhere.

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

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

For a destructive, open-world tool with four undocumented required parameters and no output schema, the description is far too thin. An agent lacks enough information about confirmation semantics and failure modes to invoke it confidently.

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

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

Schema description coverage is 0% across 4 required parameters, so the description must compensate and largely doesn't. It gestures at the file kind distinction (contract vs draft/final) but never explains campaign_id, campaign_creator_id, or the required confirmation value 'user_authorized'.

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 ('Remove') and a precisely scoped resource ('contract or exact draft/final file from its campaign creator'). It is distinguishable from siblings like list_campaign_creator_files and get_campaign_file_download, though it doesn't name those alternatives explicitly.

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

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

'Explicitly approved' and 'exact' hint at preconditions but never state when to use this versus listing or downloading files, nor what approval flow must precede it. No alternatives or exclusions are given.

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

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

Annotations already declare this as a non-read-only, open-world, non-destructive operation. The description adds important asynchronous behavior: it returns immediately, indexing usually takes minutes, and the agent must poll get_creator_catalog_status until ready_in_catalog. It does not cover idempotency or duplicate-request behavior, so it is not fully exhaustive.

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 compact sentences, front-loaded with the action, followed by return behavior and the required polling step. Every sentence contributes useful operational context.

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?

Although there is no output schema, the description explains that the call returns immediately and how to retrieve readiness via get_creator_catalog_status. Together with the fully documented input schema and annotations, an agent has enough information to invoke and follow up 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 both platform and username are already documented in the schema. The description adds only the platform scope, TikTok/Instagram, which is already captured by the enum; it does not clarify username formatting 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 uses a specific verb and resource: it queues indexing, crawl, and embed for a TikTok/Instagram creator so the creator can seed a reference search. It is clearly distinct from the sibling status-checking tool and from search_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?

It explains the use case, seeding a reference search, and explicitly names the follow-up tool to poll: get_creator_catalog_status. It does not state when not to use this tool or list alternatives, but the intended context is clear.

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

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

Annotations already declare destructiveHint=true and openWorldHint=true; the description adds real value beyond them by disclosing that the resend is partial and idempotent-safe in intent — only backend-eligible failures, never successful or uncertain recipients. It does not mention what happens on partial failure, rate limits, or what a retry returns, so it stops short of full behavioral disclosure.

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

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

Two tight sentences with the eligibility constraint front-loaded and the safety exclusion following immediately. Nothing is redundant or padded.

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

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

For a destructive, open-world mutation with three required parameters and no output schema, the description covers scope and safety but leaves gaps: no statement of what a successful retry yields, whether it returns per-recipient results, or how idempotency_key affects repeated calls. Adequate but not complete for a send operation.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning, and it mostly does not. 'Fresh user approval' loosely maps to send_confirmation's const 'user_authorized', but neither wave_id's role nor the critical idempotency_key (dedupe/replay semantics) is explained anywhere in prose.

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 scope: 'Send again only to backend-eligible failures' on a campaign email wave. It clearly distinguishes this from a blanket resend by scoping to eligible failures, though it never names a sibling tool (e.g., get_campaign_email_wave or list_campaign_email_waves) that an agent might confuse it with.

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 condition for use ('after fresh user approval') and an explicit exclusion ('Successful and uncertain recipients are never automatically resent'), which is strong when-to-use guidance. It lacks the final layer of routing to alternatives for the non-retryable cases (e.g., which tool to inspect failures with first).

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 this to be a non-destructive write operation (readOnlyHint=false, destructiveHint=false), and the description adds that saving is server-side using a search_id. It does not disclose whether saving appends or replaces roster entries, how duplicates are handled, what permissions are required, or how limit constrains the save. With annotations covering the safety profile, this is adequate but thin.

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

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

A single front-loaded sentence with no wasted words. It states the action, source, destination, and mechanism directly.

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 five-parameter write tool with only 40% schema description coverage and no output schema, the description is under-specified. An agent still lacks guidance on optional parameters and the server-side roster mutation semantics, which are important for invoking 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 only 40%, with search_id and campaign_id described in the schema. The description mentions search_id but adds no meaning beyond the schema, and it leaves limit, reference_id, and excluded_origin_ids completely unexplained in both schema and description. 'Selected or top-ranked' loosely hints at limit but does not document it.

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

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

States a specific verb ('Save'), resource ('creator search results to a campaign roster'), and source mechanism ('using search_id'). It implicitly distinguishes bulk saving from single-creator siblings like add_campaign_creator, though it does not name an alternative 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?

Usage is implied: use after a creator search with selected or top-ranked results. However, there is no explicit when-to-use/when-not guidance and no named alternatives such as add_campaign_creator, prepare_campaign_creator_selection, or copy_campaign_creators.

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

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

Annotations only give readOnlyHint=false, openWorldHint=true, destructiveHint=false, so the description carries real behavioral weight and does: it discloses the not_in_catalog prerequisite, the 409 REFERENCE_CREATOR_NOT_INDEXED failure, capability limits on YouTube, and that results are compact summaries. It also hands off search_id to save_search_results_to_campaign, telling the agent the result is reusable downstream.

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

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

Front-loaded with purpose, then progressively narrower mode/prerequisite detail; every clause carries operational information. The middle sentence is heavily semicolon-packed, which costs some readability but not 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 three-mode search with a very large filter surface, the description covers the decisions that most affect correctness: mode selection, platform-specific limits, reference indexing prerequisite, and the error path. Remaining gaps (limit, detail_level, sort_by semantics beyond the YouTube caveat) are real but secondary; no output schema exists, so the 'compact summaries' note usefully sets expectations.

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 30% across 10 parameters with a large nested filters object, so the description must compensate. It does explain kind semantics per platform and what filters YouTube honors (follower_range, creator_language, has_email), but leaves limit, sort_by, sort_order, detail_level, and the reference object shape unexplained.

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

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

States a specific verb+resource ('create a creator search') plus the return shape ('compact creator summaries'), and uses the remainder to differentiate the three search modes by platform. It does not explicitly position itself against siblings such as get_search_results or get_creator, so it falls just 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?

Explicitly routes mode selection: keyword for YouTube, semantic/reference for TikTok/Instagram. It also names hard exclusions (YouTube reference search and metric sorting unavailable), the per-platform supported arguments and filters, and the prerequisite chain (get_creator_catalog_status → request_creator_catalog_enrichment) with the 409 signal that triggers it.

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

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

Annotations already declare destructiveHint=true and openWorldHint=true, so the safety profile is partly covered. The description adds meaningful context: it emphasizes this is a REAL SEND, requires an explicit user_authorized confirmation, and mentions the idempotency key for retries. That adds value beyond the annotations, even though it does not disclose rate limits or exact post-send behavior.

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

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

The description is a single front-loaded sentence with zero wasted words. 'REAL SEND' immediately sets the tone, and the rest of the sentence delivers the essential constraints.

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 destructive real-send tool with no output schema and only 25% schema description coverage, the description is too sparse. It covers the user-authorization and idempotency safety aspects but does not document most parameters, expected behavior on success or failure, or how to choose this tool over alternatives.

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

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

Schema description coverage is only 25%, so the description should compensate for undocumented parameters. It only references idempotency_key and send_confirmation (which are already described in the schema) and gives no meaning for platform, thread_id, subject, body_text, attachments, or campaign_creator_id. Six of eight parameters remain unexplained by either schema descriptions or the tool description.

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

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

The description states a specific verb and resource: 'send one user-authorized reply to a Hyperstar inbox thread'. This clearly distinguishes a real send from sibling read/update operations like get_inbox_thread_messages or update_inbox_thread_state, though it does not name those alternatives explicitly.

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

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

Usage is implied by the phrase 'REAL SEND' and the requirement for explicit user authorization, which signals this is only for actual approved sends. However, the description does not state when to use this versus alternatives, nor does it give explicit exclusions or prerequisites beyond the authorization phrase.

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