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

Annotations only mark the tool as not read-only and not idempotent, which implies a state-changing operation. The description confirms this by saying 'Add edit slots', which indicates mutation. However, the description does not explain what 'edit slots' do conceptually, whether adding them modifies existing bundle properties, or if there are side effects on bundle state or pricing. The idempotency key parameter hints at retries, but the description lacks explicit behavioral details like 'this modifies the bundle's edit slot count' or 'would cause an error if the bundle is published'. Given the annotations carry some transparency, but leave gaps, a score of 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?

The description is short and functional, but somewhat terse. In the context of many sibling tools with similar names, a bit more detail (e.g., 'increases the number of editable slots in a bundle identified by id') would improve understanding without being verbose. It earns its place but could be slightly more descriptive to match the complexity of the domain.

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

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

Given there is no output schema, the description does not explain what the tool returns (e.g., the updated bundle object, a success message, or nothing). With a complex nested input object and 28 sibling tools, the description is too minimal to fully contextualize how this slot addition affects the bundle lifecycle. However, the schema covers parameters well, so gaps are partially mitigated. A score of 3 is fair for this minimal but not incomplete 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?

The input schema has 100% description coverage, so each parameter already has a basic description explaining its purpose (Bundle ID, JSON request body, optional idempotency key). The description adds no extra meaning beyond what the schema provides. For example, it doesn't clarify that 'quantity' must be between 1 and 500 (already in schema), or what a valid 'id' looks like. Since schema coverage is high, baseline is 3, and the description does not elevate further.

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

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

The description clearly states the verb ('Add edit slots') and the resource ('a bundle'), making the tool's primary purpose immediately clear. However, it lacks differentiation from sibling tools like 'tokportal_add_video_slots' and 'tokportal_update_bundle', which could also add or modify aspects of a bundle. The title repeats but doesn't add new context.

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

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

The description provides no guidance on when to use this tool versus alternatives. Among the many sibling tools, 'tokportal_add_video_slots' and 'tokportal_update_bundle' are obviously related, but no conditions for choosing this one are given. There is no mention of prerequisites, required state of the bundle, or scenarios where this tool is inappropriate.

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 do not mark the tool as destructive (destructiveHint=false), but adding slots implies mutation. The description does not disclose any side effects (e.g., whether this is reversible, if it can be done after publishing, or the impact on existing slots). With no output schema, the lack of detail on what confirming the mutation looks like is a 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?

The description is a single sentence of five words, which is extremely concise. However, it sacrifices necessary detail for brevity. For a tool with 3 parameters and potential side effects, a few more sentences would improve clarity without becoming verbose. Still, it effectively communicates 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?

Given the tool's complexity (3 params, 1 nested object, no output schema, no parameter enums), the description is insufficient. It does not explain the business context of 'video slots' vs. 'edit slots' (crucial with sibling tokportal_add_edit_slots), the effect on bundle state, or error conditions. The complete schema coverage and annotations are helpful but don't fill these gaps.

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

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

Schema coverage is 100%, so the baseline is 3. However, the description adds no meaning beyond the schema about parameters. Critical details are missing: the relationship between id and body, what 'quantity' represents (e.g., total video slots in bundle vs. additional slots?), and how the idempotency_key works exactly. The parameter descriptions are terse; the description could clarify these semantics.

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

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

The description clearly states this tool adds video slots to a bundle, using a specific verb ('Add') and resource ('video slots to a bundle'). Among siblings, the most similar are tokportal_add_edit_slots and tokportal_create_bundle, but the description distinguishes the slot type (video vs. edit) and the action (add vs. create), providing clear 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?

No explicit guidance is given on when to use this tool vs. alternatives like tokportal_add_edit_slots or tokportal_create_bundle. There's no mention of prerequisites (e.g., bundle must exist), exclusions (e.g., bundle must not be published), or idempotency behavior despite an idempotency_key parameter and idempotentHint=false. The agent must infer usage from the name and parameters 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 provide only generic safety hints (readOnlyHint=false, destructiveHint=false), so the description adds critical behavioral details: the task is finalized, ownership is required ('owned'), and execution is blocked if coverage is inactive. This goes beyond the annotations and informs the agent of side effects and dependencies. No contradiction with annotations.

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

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

The description is two sentences long, with the core purpose upfront and the critical execution condition second. Every word earns its place; there is no redundancy or filler.

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

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

For a simple two-parameter tool with no output schema, the description covers the essential preconditions (manual confirmation, ownership, coverage active) and the effect (approve and finalize). It could be slightly more explicit about what 'finalize' means in terms of consequences, but overall it is adequately 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?

The input schema already describes both parameters fully (id: 'Comment task ID', idempotency_key: 'Optional Idempotency-Key header for safe retries'). The description adds semantic value by clarifying that the id must refer to an owned, manually confirmed task, which is not explicit 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 clearly states the action: 'Approve a manually confirmed comment task' and elaborates with 'Approves and finalizes an owned manually_confirmed task.' It specifies the verb (approve), the resource (comment task), and the required state (manually confirmed, owned), distinguishing it from sibling tools like dispute, delete, or create.

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

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

The description provides important usage context by stating a precondition: 'Execution is blocked while TokPortal Coverage is inactive; inspect MANAGED_ACCOUNT_TASK_BLOCKED and reactivate a recoverable account first.' This tells the agent when the tool cannot be used and how to recover. However, it does not explicitly contrast with alternatives like dispute_comment_task or delete_comment_task.

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

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

Annotations indicate idempotentHint=true, but the description adds critical behavioral context: the preflight requirement, coverage prerequisites, automatic renewal behavior, and the consequence of failed renewal (no mutation starts). This goes well beyond what annotations provide, disclosing important preconditions and side effects.

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

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

The description is five sentences, front-loaded with the core purpose. Each sentence adds relevant context (preflight, coverage conditions, renewal failure). No word is wasted, but the structure could be more scannable for an agent (e.g., bullet points). Still efficient and 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?

The tool is complex (3 params, nested videos array, no output schema) and the description covers preflight and coverage conditions well. However, it fails to describe the return value or outcome (e.g., success/failure format, whether a job is created). The idempotency_key parameter is also missing from the description. Given the complexity, this omission limits completeness.

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% with all parameters documented. The description adds no parameter-level detail beyond the schema. While the high schema coverage sets a baseline of 3, the description could hint at the role of the 'videos' array (bulk configuration) but does not. It remains adequate but not additive.

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

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

The description starts with 'Configure video slots in bulk' which is a specific verb+resource pair, clearly distinguishing it from sibling tools like tokportal_configure_bundle_video (single) and tokportal_patch_bundle_video. It further specifies the bulk operation is performed after an account-level preflight, adding precision.

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 mentions the tool is for bulk configuration after a preflight and lists conditions (active coverage/grandfathered status, auto-renewal). However, it does not explicitly state when to use this over single-configure or patch alternatives, nor does it provide exclusions (e.g., if coverage cannot renew, no mutation starts). The guidance is implied but not directive for an agent.

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 enriches the destructiveHint annotation by explaining what is destroyed (coverage, but payments are kept) and the financial consequences of reactivation. No contradictions with annotations.

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

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

The description is concise with three sentences, each conveying essential information. The first sentence immediately clarifies the purpose, making it front-loaded and efficient.

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

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

For a cancel/pause tool without an output schema, the description covers enough: action, effect, and financial implications. It might miss prompting about the need for an active subscription or the time to take effect, but this is minor given the sibling list and annotations.

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

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

The input schema covers both parameters (id and idempotency_key) with clear descriptions, and the description adds context for the idempotency key via the tool's idempotentHint being false (though not stated). No additional parameter meaning is provided 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 clearly states the tool pauses TokPortal coverage, blocks new and ongoing work, and details financial implications. It distinguishes itself from siblings like tokportal_reactivate_account_managed_subscription by describing the opposite action.

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

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

It explains when to use (immediately blocking work) and mentions the cost conditions for later reactivation, but does not explicitly state when not to use this tool or compare it to other cancellation/update tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which cover the safety profile. The description adds no new behavioral context beyond what annotations provide (e.g., it doesn't mention that this is a lightweight check, or what happens if the account ID is invalid). It does not contradict annotations.

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

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

The description is a single concise sentence that communicates the core purpose without unnecessary words. It is front-loaded with the verb. However, it could be slightly more specific about the resource being checked (e.g., 'for a given account').

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 one required parameter, good annotations, and no output schema. The description is minimal but sufficient for a simple check operation. However, it doesn't explain what the return value indicates (e.g., boolean) or any edge cases (e.g., if the account is not found). Given the simplicity and annotation coverage, a 3 is reasonable.

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

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

Schema description coverage is 100%, and the single 'id' parameter is explained as 'Saved account ID.' The description adds no additional meaning beyond the schema, so a baseline of 3 is appropriate.

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

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

The title and description 'Check analytics refresh availability' clearly indicate a read-only check operation on analytics refresh status for an account. The verb 'check' combined with 'refresh availability' specifies the resource and action. However, it doesn't distinguish from sibling tools like 'tokportal_refresh_analytics_account' or 'tokportal_get_account_analytics', so a slight deduction applies.

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

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

The description implies using this tool to verify if analytics refresh is possible before performing a refresh, but it does not explicitly state when to use it versus alternatives like 'tokportal_refresh_analytics_account' or 'tokportal_get_account_analytics'. There is no guidance on prerequisites (e.g., account must exist) 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?

Beyond annotations (idempotentHint=true, destructiveHint=false), the description reveals side effects: automatic renewal of due active periods, and the fact that no task or media mutation starts if Coverage cannot renew. It also clarifies that a new account remains configurable before delivery. This adds meaningful behavioral context not present in structured fields.

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

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

The description is front-loaded with the core purpose and then provides necessary supplementary context. Each sentence contributes distinct information (backward compatibility, conditions, pre-delivery behavior). It could be slightly tighter, but it's efficient overall.

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

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

Given the tool has 3 parameters (one nested) and no output schema, the description covers the action and conditions well but omits any indication of the return value or confirmation behavior. The complexity is moderate, so this gap reduces completeness. The description is complete enough for choosing the tool but not fully for invoking without additional knowledge.

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 100% schema coverage, the baseline is 3. The description adds value by explaining the advanced_warming_terms parameter's purpose as backward-compatible and directing users to the preferred endpoint. This clarifies when to use this parameter vs. an alternative, enhancing semantic understanding 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 clearly states the verb 'Configure' and the resource 'bundle account profile', listing specific fields (username, visible name, biography, profile picture). This effectively distinguishes it from sibling tools like tokportal_configure_bundle_warming_terms and tokportal_configure_bundle_video.

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

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

The description explicitly recommends the alternative endpoint PUT /bundles/{id}/warming-terms for advanced_warming_terms, explaining why it is preferred (available at any account status). It also outlines the conditions under which the tool operates (active TokPortal Coverage or grandfathered status, auto-renewal behavior). However, it does not explicitly state when NOT to use this tool.

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

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

Beyond the annotations (idempotentHint=true, destructiveHint=false), the description discloses critical behavioral details: story rules (exactly one of video_url or story_image_url, no description), credit cost for repost, required account coverage, automatic renewal behavior, and failure conditions. This adds significant value.

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 efficient, front-loaded with the main purpose, and each sentence provides distinct information. It could be slightly more structured with bullet points for the story rules and coverage conditions, but it remains readable and avoids redundancy.

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

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

Given the complexity of the input (nested object, many sub-parameters) and no output schema, the description covers key behavioral aspects like story constraints and subscription dependencies. However, it lacks clarity on whether configuration completely replaces or merges with existing slot settings, and does not mention the response or confirmation, leaving some gaps despite annotations partially covering idempotency.

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

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

Schema coverage is 100%, so the schema itself handles most parameter documentation. The description adds meaningful context for story-related parameters (story_image_url, story_repost_url) and the video_type enum's implications, but does not elaborate on other parameters like id or position, which are adequately described in the schema.

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

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

The description clearly states the verb 'configure' and the resource 'video slot', and specifies the slot types (video, carousel, story). It distinguishes from siblings by naming the exact slot configuration, but does not explicitly differentiate from related tools like patch_bundle_video or batch_configure_bundle_videos.

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

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

The description provides context about story specifics, coverage requirements, and renewal behavior, which implies when to use this tool for story slots or under subscription constraints. However, it does not explicitly state when to prefer this tool over alternatives like patch_bundle_video, nor does it specify 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 indicate idempotentHint=true and destructiveHint=false, and the description aligns and expands significantly: it explicitly states the one-shot irreversible nature, explains the deferred configuration context, details conditions about active coverage and automatic renewal, and clarifies what happens if coverage cannot renew (no task or media mutation starts). This far exceeds bare annotations, providing rich behavioral clarity.

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 moderately sized at 5 sentences with essential information front-loaded (purpose and key constraints). While every sentence adds value, some phrases like 'In which case the warming session starts immediately' and technical jargon ('advanced_warming_terms_count') could be slightly compressed without losing meaning. Still, overall efficient for the complexity.

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

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

Given no output schema, the description effectively communicates the tool's behavior, constraints, and edge cases (grandfathered accounts, automatic renewal, account status interactions). It covers the complete workflow context—from purchase to configuration to execution—leaving no critical gaps about what the tool does or when it's applicable.

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 baseline is 3. The description adds value beyond the schema by framing the `advanced_warming_terms` parameter in the context of the purchase count and deferred configuration, reinforcing the one-shot constraint. However, it doesn't detail the exact relationship with `idempotency_key` or the body's structure beyond what the schema already states.

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

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

The description clearly identifies the tool as configuring niche targets for a count-only Advanced Niche Warming purchase, with the verb 'Configure' and specific resource 'bundle warming terms.' It distinguishes this from related tools like tokportal_configure_bundle_account by noting it stays available at any account status and is specifically for deferred configuration after purchase.

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

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

The description provides explicit when-to-use conditions (must provide exactly the purchased number of targets, one-shot behavior, works at any account status) and also implies when not to use (not for updating existing targets, since once set they cannot be changed). It indirectly distinguishes from PUT /bundles/{id}/account by contrasting availability across account statuses.

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

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

Annotations are minimal (readOnlyHint: false, destructiveHint: false, idempotentHint: false). The description goes far beyond by disclosing: the 8-credit debit, the manager resolution fallback, the atomic nature of assignment/debit/task creation, the condition that an unavailable manager never costs credits, and delivery-age eligibility rules for bundles. No contradictions with annotations exist.

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 6 sentences, highly efficient, with no filler. Every sentence adds distinct information: purpose, cost, prerequisites, fallback logic, edge cases, atomicity. Information is front-loaded (verb+resource first) and flows logically from high-level to details.

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

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

Given the tool's moderate complexity (3 params, nested object, no output schema), the description covers prerequisites, cost, fallback, atomicity, and bundle eligibility. However, it does not describe the return value or what a successful response looks like, which could help with error handling. Since there is no output schema, the description could have filled that gap. Slight deduction for missing response format.

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 baseline is 3. The description adds value by explaining that 'completed bundles remain eligible without a delivery-age limit; cancelled orders are never restored' – this context helps the agent understand the 'id' parameter's semantics for account selection. However, it does not elaborate on specific fields of the 'body' object beyond what the schema provides, missing a chance to clarify properties like 'requested_biography' or 'requested_profile_picture_url'.

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

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

The description clearly states the tool's verb ('Request'), resource ('profile edits for a delivered account'), and distinct scope. The title reinforces this. It differentiates from sibling tools like tokportal_configure_bundle_account and tokportal_get_account_edit_request by focusing on creating an edit request for an already-delivered account, not configuration or retrieval.

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

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

The description explicitly lists prerequisites: 'Active TokPortal Coverage and a routable active account manager are required.' It details the resolution fallback logic (active manager, then still-active manager relationship, then eligible non-cancelled order history). It also tells when NOT to use this tool (if manager is unavailable, no cost) and clarifies side effects (debits 8 credits, atomic operations).

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 far beyond the annotations by disclosing that the response contains a secret, is never stored in the replay ledger, and that requests with Idempotency-Key are rejected with a specific error before any operation. This is exactly the kind of critical behavioral detail agents need.

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

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

Four sentences, each earning its place: purpose, capability, critical warning, and error explanation. No redundancy, front-loaded with the main action.

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

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

For a tool with 11 optional parameters and no output schema, the description adequately covers the essential security and error behavior, though it could briefly describe the return value structure beyond just token and URL.

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 parameter details are left to the schema. The description adds no semantics about individual parameters like 'to', 'from', or 'query', which have self-explanatory names and types 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?

Clearly states it creates a shareable Analytics v2 web report and returns a token and URL. This specific verb+resource description differentiates it from sibling analytics tools like get_analytics_dashboard or export_analytics_report_html.

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 context for when to use (create a shareable report). The critical 'Do not send Idempotency-Key' warning is strong usage guidance. However, it doesn't explicitly compare to alternative tools or mention when not to use.

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

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

With sparse annotations (all false), the description provides extensive behavioral details: atomic checkout with immediate credit debit, server-side cost calculation, allowance slot consumption, cutoff policy for new customers, advanced warming purchase options and auto-cancel rules, external_ref semantics, and idempotency key role. This far exceeds minimal 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?

The description is front-loaded with the core purpose, then logically flows through payment, cost, allowances, warming options, and idempotency. Every sentence provides necessary context without redundancy, packing significant information 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?

Given the tool's complexity (nested body, conditional fields, financial implications, no output schema), the description covers all essential aspects: creation, payment timing, cost determination, allowance consumption, warming configuration, duplicate detection, and safe retry. No critical 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 descriptions cover 100% of parameters. The description adds value beyond schema by explaining how external_ref works (duplicate detection vs retry), the relationship between advanced_warming_terms and advanced_warming_terms_count, and the auto-cancel rule for count-only purchases. This nuance justifies above the baseline 3.

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

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

The description explicitly states it creates and pays three distinct bundle types (account-only, account-and-videos, videos-only) in one atomic checkout, using specific verbs and resource. This clearly differentiates it from sibling tools like get/update/publish bundles.

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

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

The description clearly defines the tool's purpose and when it should be used (creating a bundle with payment). However, it does not explicitly state when not to use it or mention alternatives like tokportal_create_bundles_bulk for multiple bundles, though the scope 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 are minimal (destructiveHint: false, but not readOnly), yet the description fully discloses: credits debited immediately on POST (not at publication), batch-level capacity checks, deterministic allowance consumption, and rollback on partial failure. It also details edge cases like crossing allowance slots and auto-cancellation of unconfigured advanced warming purchases after 14 days. No contradiction with annotations.

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

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

The description is detailed but not overly long given the complexity. It front-loads the core action and atomicity, then covers edge cases and parameter nuances. A minor deduction: the niche warming vs advanced warming explanation could be slightly more streamlined, but overall every sentence adds value.

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

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

Given the high complexity (2 parameters with nested body, 15+ sub-properties, no output schema), the description covers all essential aspects: payment timing, capacity checks, failure behavior, advanced warming options, and parameter relationships. It is complete enough for an AI agent to select and invoke this tool correctly without needing to consult documentation.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value by clarifying the atomicity context and the role of 'external_ref' (not unique, not idempotency), and elaborates on 'advanced_warming_terms' vs 'advanced_warming_terms_count' trade-offs. However, it does not describe every parameter's effect in detail (e.g., 'niche_warming_instructions' is mentioned only in the schema). Still, the description significantly enriches understanding of complex parameters.

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

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

The description clearly states the verb ('Create bundles in bulk'), resource ('bundles'), and adds critical context: atomic creation checkout, immediate debiting, and batch-level behavior. It distinguishes this from sibling tools like 'tokportal_create_bundle' by emphasizing bulk and atomicity.

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

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

The description explicitly specifies when to use this tool: for bulk creation with atomic debits and capacity checks. It explains prerequisites ('contract_bundle_allowance', 'getCreditCosts'), behavior on failure ('entire batch rolls back'), and alternatives for per-account target configuration ('PUT /bundles/{id}/warming-terms'). Also clarifies that 'external_ref' is not for retry, directing to 'Idempotency-Key'.

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 say readOnlyHint=false, destructiveHint=false, and idempotentHint=false. The description adds substantial behavioral detail: each accepted task costs 1 credit, the account is locked and revalidated before debit, accepted inserts commit in one transaction, rejected rows are never charged, and an Idempotency-Key replays the completed response without a second charge.

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

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

The description is front-loaded with the core purpose and then provides dense, non-redundant details about credits, account eligibility, transactionality, and idempotency. Every sentence earns its place; there is no filler or repetition of schema content.

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

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

For a complex creation tool with no output schema, the description covers key operational aspects: batch limits, credit charging, partial success, transaction atomicity, and safe retries. It mentions credits_charged as a response field but does not fully describe the response shape, which is a minor gap.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful parameter context beyond the schema, including the manager-assigned account requirement, credit cost per accepted task, the instruction to read credits_charged rather than calculating it, and the idempotency-key reuse guidance.

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

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

The description clearly states the tool creates comment tasks, either as a single task or a batch of up to 200. It distinguishes itself from sibling tools like list_comment_tasks, delete_comment_task, and approve_comment_task by focusing on creation and partial-success batch behavior.

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

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

The description gives clear context for when to use this tool: creating one or many comment tasks, with prerequisites such as client-owned, manager-assigned accounts and Coverage requirements. It does not explicitly name alternatives or exclusions, but the creation purpose and batch capability are unambiguous.

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

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

Annotations only indicate readOnlyHint=false, idempotentHint=false, etc. The description adds significant behavioral context: 'debits 7 credits', 'Assignment, debit, and task creation are atomic', 'Only one open request per video', and the manager selection logic. This goes beyond the sparse annotations and provides valuable insight into side effects and constraints.

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

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

The description is front-loaded with the purpose and then adds necessary constraints. However, the first two sentences are redundant: 'Request an ad code...' and 'Requests an ad code...' essentially restate the same thing. Despite this, the rest is dense with useful information and avoids fluff, so it remains reasonably concise.

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

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

The description covers prerequisites (finalized video, coverage, manager), cost (7 credits), atomicity, concurrency rule, manager selection hierarchy, and next steps (poll GET endpoint). It explains eligibility for completed bundles and never restoring cancelled orders. This is thorough for a mutation tool with no output schema, providing a complete picture of what to expect.

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%, with every parameter described (id, body with note and platform, idempotency_key). The description does not add extra semantics for these parameters beyond the schema, but it does mention 'debits 7 credits' which is a side effect, not a parameter. Since schema already documents parameters thoroughly, a baseline of 3 is appropriate.

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

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

The description clearly states the action: 'Request an ad code (TikTok Spark Code / Instagram Partner Code) for a finalized video.' This is a specific verb+resource combination, and it distinguishes this tool from siblings—no other sibling creates ad code requests. The title similarly reinforces the purpose, so there's no ambiguity.

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

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

The description gives explicit when to use: 'for a finalized video' and prerequisites: 'video must be finalized on TikTok or Instagram with a live post link. Active TokPortal Coverage and a routable active account manager are required.' It also notes 'Only one open request per video is allowed' and directs to poll the GET endpoint. It doesn't explicitly list alternatives, but given no sibling does this, it's clear enough.

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

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

Discloses critical behavioral traits not evident from annotations: the response contains a secret that is never stored in the replay ledger, and sending Idempotency-Key results in a 400 error before any ledger claim or execution. This adds significant value beyond the annotations, which only indicate mutability and non-idempotence.

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 extremely concise—three sentences—and front-loaded with the action. Every sentence conveys essential information without clutter. It wastes no words and is highly scannable.

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

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

Given the nested body and extensive event enum in the schema, the description covers the most critical operational aspects (secret handling, idempotency-key rejection). It does not explain the return format or the meaning of 'enabled'/'description', but the schema covers those. Overall, it is sufficiently complete for a create operation with a sensitive response.

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% (body has a description), but the tool description does not add detail about individual parameters. It does mention the sensitive response, but that is about the tool's behavior, not parameter meanings. The baseline of 3 applies since the schema holds the parameter structure; the description doesn't compensate further.

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

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

The description clearly states the action: 'Create a webhook endpoint.' It is distinct from sibling tools (list, update, delete, test) by the verb 'create'. The purpose is unambiguous and specific to the resource.

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

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

Provides explicit usage guidance: warns against sending Idempotency-Key, explains the need to store the signing secret, and describes the rejection behavior with a specific error code. This is above-and-beyond typical guidance and directly addresses potential misuse.

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

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

Annotations already mark destructiveHint=true and idempotentHint=true, but the description adds significant nuance: atomicity of terminal transition and refund, authoritative credits_refunded for historical tasks, and availability during Coverage pause. It also explains the idempotency key reuse after uncertain transport results, which is beyond the generic hint.

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

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

The description is four sentences, each packing essential information. It leads with the primary purpose, then details behavioral nuances and idempotency guidance. No fluff or redundancy; it's concise while being informative.

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, credit-affecting mutation with no output schema, the description covers all necessary aspects: conditions (pending, owned), atomicity, idempotency, refund amounts, behavior under paused coverage, and retry guidance. It is self-sufficient and leaves no obvious gaps for an agent to misuse the tool.

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

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

The schema covers all three parameters with descriptions (100% coverage). The description adds value by explicitly instructing to reuse the same Idempotency-Key after uncertain results, and it clarifies the refund semantics that relate to the 'id' parameter. While it doesn't elaborate on each parameter individually, the guidance on the idempotency key is a meaningful addition beyond the schema.

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

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

The description opens with a precise verb+resource pair: 'Cancel a pending comment task.' This clearly distinguishes it from sibling tools like approve, dispute, or list comment tasks. It also states the scope: only owned tasks with pending status.

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

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

It states when to use: cancel a pending owned task, and even mentions a specific edge case (when Coverage is paused). It does not explicitly name alternatives or say when not to use, but the context is clear from the sibling list. The condition 'owned task only while its status is pending' provides concrete guidance.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the agent knows this is a dangerous, non-read operation. The description adds the idempotency key parameter, which hints at retry safety — but doesn't mention what actually gets destroyed (e.g., does it delete related deliveries as well?), or whether hitting the same endpoint twice with different IDs has side effects. Acceptable given annotations but no added depth.

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?

Single sentence, zero waste, front-loads the intent immediately. The imperative mood signals the action, and every token pulls weight. Structure is optimal for what it does.

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 delete tool with 2 parameters, 100% schema coverage, and strong annotation hints (destructive/idempotent), the description is nearly complete. However, no output schema exists, so the agent gets no signal on what a successful delete returns — a note on this would push it to 4. It also doesn't verify whether the ID refers to the URL path parameter vs body ID, which matters in RESTful designs.

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

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

Schema description coverage is 100% — both 'id' and 'idempotency_key' are documented in the schema itself. The description adds zero parameter context beyond that, but the schema covers the full burden. Baseline 3 is appropriate here since the description doesn't need to compensate for any coverage gaps while also adding no additional meaning like required-format or example values.

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

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

The description 'Delete a webhook endpoint.' uses a specific verb-plus-resource structure with clear intent. It's brief but unambiguous; however, it doesn't explicitly differentiate itself from sibling tools like 'update_webhook_endpoint' or 'test_webhook_endpoint' — though the verb 'delete' makes the distinction self-evident.

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 when-to-use or when-not-to-use guidance is provided. The description doesn't mention whether this is a hard delete, whether it requires confirmation, or how it relates to other webhook tools. Unlike the HIGH example that references alternatives like 'use search_calls_extensive instead,' this gives no context about effect of deleting an endpoint while deliveries might be in-flight.

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

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

Annotations are minimal (readOnlyHint=false, destructiveHint=false) and do not explain the mutation's effect. The description adds value by stating the exact state transition (to pending corrections) and the critical blocking condition (inactive coverage) with recovery steps. It does not cover idempotency behaviors or error responses beyond the coverage block, but the core behavioral traits are well 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?

The description is extremely concise: two sentences, no wasted words. The first sentence immediately conveys the purpose, and the second adds a crucial behavioral warning. Every sentence earns its place.

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

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

With no output schema, the description could be more complete by indicating what the tool returns on success (e.g., the updated task object). It covers the main behavioral aspects (state change, blocking condition) but omits success response format and common error cases. Given the tool's moderate complexity, it is mostly complete but has a minor gap.

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

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

Schema coverage is 100% with adequate descriptions for id (Comment task ID), body (JSON request body with reason), and idempotency_key (Optional Idempotency-Key header). The description adds no extra meaning to these parameters (e.g., valid reason formats, constraints on id). According to guidelines, high schema coverage earns a baseline of 3, and no additional param information is provided.

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

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

The description clearly states the specific action ('Dispute a manually confirmed comment task') and the resulting state change ('Returns an owned manually_confirmed task to pending corrections'). This distinguishes it clearly from sibling tools like approve, delete, or create by naming a unique operation and outcome.

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

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

The description provides explicit context on when to use (disputing a manually confirmed task) and an important precondition: execution is blocked when TokPortal Coverage is inactive, with clear instructions to inspect MANAGED_ACCOUNT_TASK_BLOCKED and reactivate a recoverable account first. It lacks an explicit 'do not use if' statement or comparison with alternatives like approve, but the precondition guidance is strong enough for a 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 provide no positive safety signals (readOnlyHint=false, idempotentHint=false), and the description only says it creates a standalone downloadable HTML report. It does not disclose whether this triggers a file download, returns HTML content, requires existing analytics data, or has side effects like rate-limited export generation.

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

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

Two short sentences, front-loaded with the tool's purpose, with no filler. The second sentence adds meaningful detail about the standalone/downloadable nature of the output.

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 complex nested body of 11 optional fields, the description should clarify the return value and required setup. It does not mention whether the report is generated asynchronously, how the HTML is returned, or what prerequisites exist, leaving 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?

The schema lists 100% coverage for the top-level parameters, and the body parameter is described as 'JSON request body.' However, the description adds no semantic detail for the many nested filter fields (dates, platforms, accountIds, etc.), so an agent must infer their meaning from names and types alone.

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

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

The description uses a specific verb ('Export') and resource ('analytics report HTML') and adds 'standalone downloadable' to clarify the output format. This distinguishes it from sibling tools like tokportal_export_analytics_videos and tokportal_create_analytics_report.

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

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

No guidance is provided on when to use this tool versus alternatives such as tokportal_create_analytics_report or tokportal_get_analytics_dashboard. The name implies export, but there is no explicit context, prerequisites, or exclusion criteria.

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 no behavioral context beyond what annotations already declare (readOnlyHint, idempotentHint, destructiveHint false). It doesn't mention that this is an export that produces a file, whether it's synchronous, what data is included, or the CSV format. With annotations covering safety, the description still lacks value like 'exports data for a given date range and filters' which is crucial.

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, straightforward sentence. It is extremely concise and front-loaded with the core action. No fluff, but it may be too brief to convey necessary context. Given that the schema covers parameters, this level of brevity is acceptable.

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, all optional, and no output schema, the description should clarify what the exported CSV contains, whether it's all videos or filtered, and any constraints. The single sentence leaves substantial ambiguity. The agent cannot infer the result format or the scope without prior knowledge. This is incomplete for a tool with such a generic name.

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

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

Schema description coverage is 100%, so all 7 parameters are documented with descriptions in the schema. The description itself doesn't add any parameter-level meaning, but that's acceptable since the schema does the heavy lifting. The baseline of 3 applies because the description provides no extra context about how parameters interact or default behavior.

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

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

The description 'Export analytics videos CSV' clearly states the action (export) and the resource (analytics videos) with output format (CSV). It's distinguishable from sibling export tool tokportal_export_analytics_report_html which exports reports as HTML, and other analytics tools focus on retrieval/dashboard, not export. However, it doesn't specify the scope of videos (all? filtered?) which could be clearer.

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

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

There is no guidance on when to use this tool versus alternatives. No mention of prerequisites, typical scenarios, or that it's for data extraction vs real-time viewing. Sibling tools like tokportal_get_analytics_dashboard or tokportal_get_analytics_series are not referenced, so the agent has no direction on choosing this export tool over them.

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

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

Annotations already set destructiveHint=false, readOnlyHint=false, idempotentHint=false, indicating this is a non-read, potentially non-idempotent write. The description clarifies it is an approval/marking action, which adds behavioral context beyond annotations. No contradictions found.

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, direct sentences providing the core action and outcome. No filler or redundant words. Every part adds value.

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

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

Given the simplicity (2 params, no output schema, no nested objects), the description covers the essential action. It could mention that the action changes account state (from in-review to finalized) or outline the return type implicitly, but the lack of output schema does not require exhaustive detail. The 100% schema coverage compensates.

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

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

Schema description coverage is 100% (both parameters have individual descriptions). The first sentence of the tool description adds general purpose but no extra parameter-specific detail. The idempotency_key is a common pattern and the schema already explains it. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Finalize') and a clear resource ('account review') plus an explicit outcome: 'Approves an in-review account and marks it finalized.' This clearly distinguishes it from sibling tools like tokportal_request_bundle_account_corrections or tokportal_get_bundle_account.

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 it is for finalized an in-review account, but does not provide explicit guidance on when not to use it, prerequisites (e.g., account must be in 'in-review' state), or alternatives among the many sibling tools. The context is implied but lacks clear boundaries.

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

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

The description discloses key behavioral traits beyond annotations: it explains that the tool may automatically renew coverage at the stored rate, and that no task or media mutation occurs if coverage cannot renew. This provides actionable context about conditional side effects. Annotations already indicate non-read-only and non-destructive, and the description complements them without contradiction.

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

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

The description is three sentences long, with the first sentence stating the purpose directly. The subsequent sentences add necessary conditional details without repetition or fluff. Every sentence contributes value, making it highly efficient.

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

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

The description lacks information about what happens on successful finalization (e.g., return value, state change confirmation). Terms like 'due active period' and 'stored rate' are unexplained, assuming domain knowledge. Given no output schema, the description should clarify the outcome and key concepts to be truly 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?

The input schema has 100% description coverage for all three parameters (id, position, idempotency_key). The tool description adds no additional meaning or usage context for these parameters, so the baseline score of 3 is appropriate.

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

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

The description opens with 'Finalize video review,' which clearly states the verb and resource. It distinguishes from sibling 'tokportal_finalize_bundle_account' by targeting video specifically. However, the rest of the description focuses on account coverage conditions rather than elaborating what 'finalize' entails (e.g., marking the review as complete), leaving some ambiguity about the exact action.

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

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

No explicit guidance is given on when to use this tool versus similar siblings like tokportal_publish_bundle_video, tokportal_configure_bundle_video, or tokportal_finalize_bundle_account. The prerequisites are stated (active coverage or grandfathered account), but there is no direct mention of when this step is appropriate or when alternatives should be chosen.

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

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

The description discloses behavioral traits beyond the annotations: it explains the conditional execution based on coverage renewal, the replacement of URLs, and the clearing of a download issue flag. This adds valuable context that annotations (which only indicate non-readonly, non-idempotent, non-destructive) do not cover. No contradiction with annotations.

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

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

The description is four sentences, all essential and front-loaded with the primary action. Each sentence adds unique information: the core fix action, the replacement target, the coverage condition, and the no-op fallback. No extraneous words or repetition.

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

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

Given the complexity (4 parameters, nested object, no output schema), the description covers purpose and preconditions well. However, it omits details like what happens on success (return value or status), error scenarios, or definitions of domain terms like 'TokPortal Coverage'. This leaves gaps for an agent needing to understand the full outcome and edge cases.

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

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

The input schema already has 100% description coverage for all 4 parameters, including details about UUID, body structure, position, and idempotency key. The description does not add further meaning to any specific parameter beyond what the schema provides. It mentions 'video or carousel download URL' which aligns with the body fields, but adds no new syntactic or semantic detail.

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

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

The description clearly states the tool's purpose: 'Fix a broken video download' by replacing a manager-flagged broken download URL and clearing the issue flag. This is a specific verb-resource combination. It distinguishes itself from sibling tools like 'update_bundle' or 'publish_bundle_video' by focusing on fixing broken downloads flagged by a manager.

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

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

The description provides usage context by specifying prerequisites: the bundle must resolve to a delivered saved account with active TokPortal Coverage or be permanently grandfathered. It also explains that a due active period can renew automatically, and if coverage cannot renew, no mutation occurs. This gives clear conditions for execution, though it does not explicitly mention when to avoid this tool in favor of alternatives (which are lacking as direct substitutes).

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 provide no safety profile (all false), so the description carries the burden. It states the tool generates search terms and is free, but does not disclose any side effects, latency, or return format. For a generation tool this is adequate but not rich.

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 sentences, front-loaded with the purpose and immediately followed by actionable usage guidance. No wasted words, all information earns its place.

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

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

The tool is moderately complex (nested body, multiple params) but the schema documents everything. The description provides essential downstream integration context (where to pass the result) and cost info, which makes it complete for an agent. It lacks output format details but no output schema exists, so it is reasonably 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 100%, so the parameters are fully documented in the schema (text, count, platform, idempotency_key). The description adds minimal extra parameter context beyond saying the input is a free-text niche description, matching the schema. Thus it meets the baseline but does not elevate it.

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

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

The description clearly states the verb 'Generate' and the specific resource 'Advanced Niche Warming search terms', and distinguishes it from siblings by noting the result is passed to other tools (advanced_warming_terms or search_terms) and by the 'Advanced Niche Warming' qualifier.

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

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

It explicitly explains how to use the output (pass to advanced_warming_terms or search_terms) and mentions that it is free and no credits are charged, giving clear context. It does not explicitly state when not to use it, but the downstream usage guidance is sufficient.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the description doesn't need to repeat those. However, it adds no context about what 'account' means, what 'delivered' implies, or any side effects. The description provides no extra behavioral context beyond the annotations.

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

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

The description is a single, short sentence with no wasted words. It's front-loaded with the verb and resource. However, it lacks any additional structured information like examples or related tools, which is acceptable given its brevity.

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 simple single-parameter getter with good annotations, so it doesn't need extensive description. However, the term 'delivered' is ambiguous, and there are many account-related sibling tools. Without clarifying what type of account this refers to (e.g., in contrast to tokportal_get_bundle_account), the description feels incomplete for an agent to reliably select it.

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

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

There is only one parameter ('id'), and the schema description says 'Saved account ID.' with full coverage. The tool description adds nothing beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description 'Get a delivered account.' specifies a verb and resource, but it's quite vague. It doesn't clarify what 'delivered' means in context, and among many sibling tools that start with 'tokportal_get_*', the differentiation is minimal. The title repeats the description, adding no extra clarity.

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

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

There is no guidance on when to use this tool versus alternatives like tokportal_get_bundle_account or tokportal_get_account_managed_subscription. It doesn't mention prerequisites or when not to use it, leaving the agent to infer from the name alone.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering safety. However, the description adds no extra behavioral context—it does not explain what a 'compatibility view' entails, any expected output, or limitations. It simply restates the title, providing no value beyond annotations.

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

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

A single, succinct sentence fully conveys the tool's basic purpose with no redundancy. It is appropriately sized for a simple getter operation.

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

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

Given the ambiguity of 'compatibility view' and the lack of an output schema, the description is incomplete. It does not explain what the response contains or why this view differs from other analytics tools. The tool is also one of many closely related siblings, so more context is needed to justify its existence.

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%—the sole parameter 'id' is fully described as 'Saved account ID.' The description does not add any additional meaning, which is acceptable given the high coverage. The baseline of 3 is appropriate.

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

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

The description explicitly states 'Get account analytics compatibility view,' which uses a specific verb and resource. It is clear what the tool does but does not differentiate from siblings like 'get_analytics_account' or 'get_analytics_dashboard,' so it loses a point for lack of distinction.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention any specific context, prerequisites, or exclusions, leaving the agent to guess which of the many analytics-related siblings is appropriate.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the bar is lower. The description adds the 'active' filter, which is a behavioral constraint beyond annotations. However, it does not disclose what happens if no active request exists or describe the response format, leaving some transparency gaps.

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

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

The description is a single sentence of five words, extremely concise and front-loaded. Every word earns its place with no wasted information.

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

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

The tool is simple (one parameter, read-only, no output schema). The description is minimal: it states the action and resource but does not explain what an 'edit request' is or what the return value looks like. While the parameter description clarifies that 'id' is the account ID, the overall description could be more complete by explicitly linking the account ID to the request retrieval.

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% with the parameter 'id' described as 'Saved account ID.' The description adds no further parameter meaning beyond what the schema already provides. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description explicitly states the action ('Get') and the resource ('active account edit request'), which is specific and distinct from sibling tools like 'create_account_edit_request'. It is not a tautology of the name because it adds the qualifier 'active', clarifying the scope.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., when to use create_account_edit_request instead, or what to do if no active request exists). With many sibling tools, the lack of explicit usage context is a significant gap.

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 significant behavioral details beyond the annotations (readOnlyHint, idempotentHint, destructiveHint). It explains eventual consistency at period end, the purpose of period_expired, zero-credit quote validity, and the meaning of missing records (grandfathering vs. ineligibility). This fully informs the agent of the tool's 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 10+ sentences and covers many details, making it thorough but not concise. It is front-loaded with the primary purpose, but some sentences are technical and could be streamlined. The structure is logical but could be more compact for agent efficiency.

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

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

Given the lack of an output schema, the description lists the key return fields (status, current period, rate, unpaid periods, task access, quote) and explains edge cases (grandfathering, missing record, zero-credit quote). It covers timing behavior and eligibility. While it doesn't enumerate all possible status values, it provides enough context for the agent to understand the response structure.

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

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

The schema already provides a description for the 'id' parameter ('Saved account ID.'). The description adds context about eligibility ('one eligible saved account'), tying the parameter to the tool's business logic. While it doesn't add format details, it clarifies the parameter's role in identifying accounts that can have subscription status, which is a meaningful addition 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 clearly states the tool's purpose: 'Get TokPortal Coverage status' and enumerates specific return fields (effective status, current period, rate, unpaid periods, task access, reactivation quote). It distinguishes from sibling tools like tokportal_get_account (general account info) and tokportal_reactivate_account_managed_subscription (mutation) by focusing on the subscription status retrieval.

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

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

The description provides context about when to use the tool (e.g., checking eligibility, inferring grandfathering from a 404) but does not explicitly state when to prefer this tool over alternatives like tokportal_get_account or the subscription mutation tools. It gives implied usage through edge-case explanations but lacks explicit when-to-use or when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. However, the description adds almost no behavioral context beyond the word 'drilldown'—it does not explain what data is returned, whether it is a summary or detail view, or how it relates to other analytics tools.

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

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

The description is short and front-loaded, but it is under-specified rather than efficiently informative. The phrase 'account analytics drilldown' is jargon-heavy and does not add meaningful clarity beyond the tool name.

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

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

The tool is simple with one parameter and good annotations, but there is no output schema and the description does not explain what a 'drilldown' contains or when this tool should be used. The presence of multiple analytics sibling tools makes the missing context more significant.

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% for the single required 'id' parameter, which is described as 'Saved account ID.' The description adds no additional parameter semantics, but the schema already provides sufficient meaning, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb and resource ('Get account analytics drilldown'), but the term 'drilldown' is vague and not clearly defined. It also does not distinguish this tool from the similarly named sibling tokportal_get_account_analytics, leaving ambiguity about what this tool uniquely returns.

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

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

There is no guidance on when to use this tool versus alternatives such as tokportal_get_account_analytics, tokportal_get_analytics_dashboard, or tokportal_get_analytics_series. The description provides no context, 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 already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds value by enumerating the contents of the returned contract, giving the agent a clearer expectation of what the response will include beyond the mere fact it is read-only.

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 concise sentences, with the primary purpose front-loaded and the return contents listed efficiently. Every word adds informational value, with no redundant phrases or filler.

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

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

For a parameterless getter tool with good annotations, the description sufficiently explains what it does and what it returns. It could potentially mention use cases or related tools, but given its simplicity and the absence of output schema, it is adequate. The brief listing of returned elements covers what an agent needs to know.

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

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

The tool has zero parameters, so the baseline is 4. There is no requirement for parameter explanations, and the description correctly focuses on the return value. The schema coverage is trivially 100% since there are no properties to document.

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

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

The description clearly identifies the tool as retrieving the analytics data contract, listing specific contents (Analytics v2 contract, access payload, metric semantics, freshness targets, redaction rules). This differentiates it from sibling analytics tools like get_analytics_dashboard or get_analytics_account, which serve different purposes.

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

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

The description implies its use for obtaining the analytics contract but provides no explicit guidance on when to choose it over alternatives. It does not mention prerequisites, typical scenarios, or exclusions, leaving the agent to infer from the name and 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?

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds no behavioral information. It does not describe what data is returned, how filters interact, or any side effects. The description is entirely silent on behavior, which is a critical gap for a data-fetching tool.

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

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

The description is extremely concise, consisting of a single sentence with no wasted words. However, it is so brief that it lacks substantive content, which is a trade-off. It is well-structured and front-loaded, but the brevity borders on under-specification.

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 is the only source for understanding what the tool returns. It does not explain the dashboard's contents, the effect of filters, or any field details. Given six parameters and no behavioral guidance, this is severely incomplete for an effective tool description.

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

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

The input schema has 100% coverage, but the parameter descriptions are tautological ('query parameter to', 'query parameter from') and do not explain what the parameters mean. The description adds no additional interpretation. Given the low quality of schema descriptions, the tool description should compensate, but it does not, leaving the agent without meaningful parameter semantics.

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

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

The description 'Get analytics dashboard' clearly indicates a verb+resource pair, but it lacks specificity about what the dashboard contains or how it differs from sibling tools like get_analytics_series, get_analytics_contract, or get_analytics_account. It is not a tautology, but it is too vague to distinguish from similar analytics 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?

There is no guidance on when to use this tool versus alternatives. The description does not mention any context, prerequisites, or exclusions. It simply states the action without explaining the appropriate use case, leaving the agent to guess.

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 agent knows this is a safe read. The description adds nothing about behavior beyond the title, such as whether it returns raw snapshots or aggregated data. It neither contradicts nor significantly enriches the annotation-covered behavioral profile, so a mid-range score 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?

The description is a single short sentence: 'Get analytics time series.' This is efficient and gets to the point immediately. It is not padded with fluff, but it is almost too terse, missing an opportunity to include use-case hints. The title repeats the description, doubling up, but since the title is structural rather than part of the description, it doesn't penalize. For the description itself, 4 is generous but reasonable given the brevity and 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?

There is no output schema, so the description carries the burden of explaining what the response contains. It does not mention the type of time series data (e.g., per-day metrics, cumulative vs snapshot mode), pagination, limits, or how 'account' affects results. With 6 parameters and no output schema, the description is insufficient to fully guide the agent, especially given the complex sibling ecosystem.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description adds no new param context beyond the schema, but it doesn't need to since the schema fully documents each parameter. The description does not clarify relationships between parameters (e.g., how 'account' interacts with 'metric'), but that is optional given the high schema coverage. No compensatory info is needed, so 3 is fair.

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

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

The description says 'Get analytics time series' which clearly indicates a read operation for analytics data. However, it doesn't distinguish from siblings like tokportal_get_analytics_dashboard, tokportal_get_analytics_contract, or tokportal_get_account_analytics, which may also retrieve analytics data. The verb 'Get' is generic, though the resource is specific.

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

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

There is no guidance on when to use this tool versus the many other analytics-related sibling tools (e.g., tokportal_get_analytics_dashboard, tokportal_get_analytics_contract, tokportal_get_account_analytics). The description does not mention any context or exclusions, leaving the agent to guess based on the tool name alone. This is a significant gap given the large sibling set with overlapping purposes.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds no behavioral context—no mention of authentication requirements, rate limits, scoping, or response behavior. With annotations present, the description's burden is lower, but it still contributes nothing beyond what is already structured.

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 extremely short (3 words) but this is under-specification rather than efficient conciseness. It lacks essential context and requires the agent to infer the tool's purpose. A single sentence can be concise yet informative; this one is not.

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

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

Given the tool's complexity (many sibling tools, no output schema, only one parameter), the description is completely inadequate. It does not explain what a bundle is, what fields are returned, any prerequisites, or how output differs from other get tools. The missing output schema increases the burden on the description, which it fails to meet.

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% (1 parameter 'id' with format uuid and description 'Bundle ID.'). The description "Get a bundle." does not add any meaning to the parameter beyond what the schema provides. Baseline 3 is appropriate since the schema is self-sufficient.

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

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

The description "Get a bundle." is a near-tautology of the tool name. It states the verb and resource but provides no differentiation from sibling tools like tokportal_get_bundle_publish_readiness, tokportal_get_bundle_account, or tokportal_get_bundle_video. The agent cannot infer what a 'bundle' is or what specific data this tool retrieves.

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

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

No guidance is given on when to use this tool versus alternatives. The sibling list includes many 'get' tools (e.g., tokportal_list_bundles, tokportal_get_bundle_publish_readiness, tokportal_get_bundle_account) without any criteria to choose among them. This is a critical omission.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no additional behavioral context (e.g., what the configuration contains, whether it requires an active bundle account). With annotations present, the description is minimally acceptable but does not enrich transparency.

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

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

The description is a single short sentence that earns its place by clarifying the target resource ('configuration'). It is efficient but slightly repetitive with the tool name. No wasted words, though a bit more structure (e.g., specifying it is read-only) would be beneficial.

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

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

For a simple one-parameter retrieval tool with good annotations, the description is adequate but not complete. It does not hint at the return shape (no output schema) or any contextual details like whether the configuration includes nested objects. The sibling tools suggest complex account management, so some additional context would help an AI agent.

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

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

Schema description coverage is 100% (the single parameter 'id' has description 'Bundle ID.'). The tool description does not add any extra meaning for the parameter beyond what the schema already provides. Baseline of 3 is appropriate.

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

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

The description 'Get bundle account configuration' clearly identifies the verb ('Get') and resource ('bundle account configuration'), which adds specificity beyond the tool name. However, it does not distinguish this from sibling tools like tokportal_get_bundle (which retrieves a bundle) or tokportal_get_account (which gets an account).

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

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

No guidance on when to use this tool versus alternatives. The description does not mention any prerequisites, exclusions, or preferred contexts. For example, it could note that this tool retrieves the configuration of a bundle account, while tokportal_configure_bundle_account is used to update 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 and destructiveHint=false. The description adds value by stating it does not 'settle Coverage, or debit credits' and explains temporary blocking behavior due to due periods. No contradiction with annotations.

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

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

The description is five sentences with the purpose front-loaded. It includes specific blocker type details and a recommendation to fetch another endpoint, which is useful but slightly verbose. Still efficient for the information conveyed.

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

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

Given the single parameter and no output schema, the description adequately explains the tool's purpose, return value (publish blockers), and a special case (temporary blocking). It does not detail the full output structure, but that is acceptable without an output schema.

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

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

Schema coverage is 100% with a single parameter 'id' described as 'Bundle ID.'. The description does not add any additional parameter-level details beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description clearly states the verb 'Check' and the resource 'bundle publish readiness', and explicitly distinguishes this from mutation tools by stating 'without mutating the bundle'. It also differentiates from sibling tools like tokportal_publish_bundle by focusing on readiness checks.

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

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

The description provides context for when to use the tool (checking readiness before publishing) and mentions fetching the managed-subscription endpoint for authoritative state. However, it does not explicitly exclude scenarios or compare directly with sibling tools like tokportal_get_bundle.

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

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

Annotations declare this tool is read-only (readOnlyHint: true), idempotent, and non-destructive. The description simply restates this as 'Get...', which aligns but adds no additional context beyond the annotations. For a tool inferred to be read-only from the name and annotations, this is adequate. However, the description does not disclose if the returned 'video slot configuration' is a simple value, object, or list, or if there are side-effects like recording access.

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, short sentence 'Get video slot configuration.' which is concise but lacks structure. It front-loads the verb 'Get' which is good, but the brevity comes at the cost of clarity. There is no wasted text, but the sentence feels incomplete and could benefit from adding context about the bundle binding without being verbose.

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

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

Given the absence of an output schema, the description should clarify what is returned by this configuration retrieval. The tool has 2 required parameters and many siblings, so a bit more context is needed for an agent to use it correctly. The description does not explain the concept of a 'video slot' or how it relates to a 'bundle', leaving the agent to infer from the parameter names.

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

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

The schema provides 100% coverage with detailed descriptions for both parameters: 'Bundle ID.' (UUID format) and '1-based video slot position.' (integer, minimum 1). The description adds no further semantic meaning beyond what is already in the schema. The context signals indicate schema coverage is high, so a baseline score of 3 is appropriate.

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

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

The description 'Get video slot configuration' is vague. While it conveys a read operation on a 'video slot configuration', it fails to specify that this configuration is scoped to a bundle and the role of the 'id' and 'position' parameters, which is crucial for understanding the tool's resource. This vagueness makes it hard to distinguish from the many sibling tools like 'tokportal_configure_bundle_video' which modifies a similar resource or 'tokportal_list_bundle_videos' which returns a list.

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

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

The description provides no guidance on when to use this tool versus its siblings. For example, an agent could confuse this tool with 'tokportal_list_bundle_videos' (which lists videos in a bundle) or 'tokportal_configure_bundle_video' (which modifies a single video slot). The readOnlyHint annotation implies it is safe to call anytime, but the description does not clarify this or give any context on preconditions.

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

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

The annotations already disclose that this is read-only, idempotent, and non-destructive, and the description adds no behavioral context beyond that—no rate limits, aggregation behavior, date-range semantics, or pagination details. There is no contradiction with annotations, but the description carries none of the transparency burden.

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

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

The description is concise and front-loaded as a single sentence, but it is so terse that it approaches under-specification. It uses its space efficiently but misses the opportunity to define 'pulse' or explain the key filters, making the brevity less helpful than it could be.

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

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

Given 8 optional parameters, a rich sibling set, and no output schema, the description is too thin to be complete. It does not explain the return shape, what 'comment pulse' means, how filters interact, or why this tool is distinct from other comment/analytics endpoints.

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

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

Schema description coverage is 100%, so the baseline is 3, but the schema descriptions are mostly tautological ('query parameter to'). The tool description adds no parameter meaning, leaving the agent to infer the roles of fields like post, account, country, and postLimit from names alone.

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

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

The description 'Get comment pulse analytics' names a specific verb and resource, making the basic purpose clear. However, 'pulse' is undefined and it does little to distinguish this from sibling analytics tools such as get_analytics_series or list_analytics_account_comments.

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

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

No guidance is given about when to use this tool versus alternatives. The description and name imply 'use it for comment pulse analytics,' but there is no context, exclusions, or comparison to the many sibling analytics/comment tools.

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

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

Annotations already declare readOnlyHint and idempotentHint, but the description adds behavioral context: it returns only owned comment tasks and includes coverage blocking details and stable block reason. This goes beyond annotations and clarifies important agent-facing 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?

Two sentences, front-loaded with the primary action. Every word adds value; there is no redundancy or filler. Highly efficient for an agent to parse.

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

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

Given the simple tool (single parameter, no output schema, rich annotations), the description covers the core functionality and partial output. It could be more complete by explicitly stating that it returns a single task or errors if not found, but the current level is adequate for most use cases.

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

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

With 100% schema description coverage, the baseline is 3. The tool description does not add any additional meaning or constraints beyond the schema's 'Comment task ID.' No further explanation is provided for the id parameter.

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

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

The description clearly states 'Get a comment task' with a specific verb and resource. It goes beyond by specifying it returns an owned comment task and includes coverage blocking information, which distinguishes it from sibling list tools like tokportal_list_comment_tasks.

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 usage is implied by the required id parameter: it fetches a specific task by ID. However, the description does not explicitly state when to use this over alternatives (e.g., tokportal_list_comment_tasks to browse), and it provides no guidance on prerequisites 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, idempotentHint: true, and destructiveHint: false, which fully convey the safe, read-only nature. The description adds no behavioral details beyond what annotations provide, but does not contradict them. A 4 is appropriate because annotations carry the burden effectively.

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 extremely concise at two words, which is acceptable for a simple, parameterless tool. It is front-loaded but borders on being underspecified relative to the number of sibling tools.

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 parameterless tool with no output schema, the description is minimally complete. However, it could briefly mention the return value (e.g., currency, format) to improve completeness, especially given the large sibling set where credit-related tools exist.

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

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

The tool has zero parameters, so the description has nothing to clarify beyond the schema. With 100% schema description coverage, the baseline of 3 is correct, as no additional parameter information is needed.

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 'Get credit balance' clearly states the verb (get) and resource (credit balance), making the basic purpose understandable. However, it does not differentiate this from similar getters like tokportal_get_credit_costs, leaving ambiguity about the specific data returned.

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

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

No guidance is provided on when to use this tool versus alternatives, such as distinguishing it from tokportal_get_credit_costs or tokportal_list_credit_transactions. The agent must infer usage solely from the tool's name and description.

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

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

Annotations already provide readOnlyHint: true, idempotentHint: true, destructiveHint: false. The description 'Get credit pricing' aligns with those and is consistent (neither contradicts nor adds beyond them). It adds no extra behavioral context like return format or scope, so a baseline 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?

The description is a single, short sentence that conveys the purpose. It could be slightly front-loaded but is appropriately sized for a parameterless tool. No wasted words.

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

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

For a simple, parameterless, read-only tool with comprehensive annotations and no output schema needed, the description is nearly complete. It might benefit from noting it returns pricing info, but given the low complexity, it is adequate.

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

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

The input schema has zero parameters and schema description coverage is 100%, so there is no parameter description burden. The tool requires no inputs, and the description correctly implies it is a simple fetch. It adds sufficient meaning that no parameters are needed.

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 'Get credit pricing' uses a clear verb ('Get') and resource ('credit pricing'), and there are sibling tools like 'tokportal_get_credit_balance' and 'tokportal_list_credit_transactions' that suggest different credit-related operations, aiding distinction.

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

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

There is no guidance on when to use this tool versus alternatives. Among siblings, some are also getters (e.g., 'tokportal_get_credit_balance'), and the description provides no context for when to choose this one, such as what pricing information it returns.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint , so the safety profile is covered. However, the description adds no additional behavioral context (e.g., what data is returned, authentication implications). Minimal value beyond annotations.

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

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

Extremely concise (3 words), front-loaded, and to the point. No wasted words. However, it could be slightly expanded to include output context without losing conciseness.

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?

Without an output schema, the description should hint at what the response contains (e.g., user profile, permissions). It doesn't, leaving the agent guessing. For a simple tool this 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?

The tool has zero parameters and schema coverage is 100%, so no parameter information is needed. The description does not add parameter details, but that's acceptable given there are none.

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 'Get authenticated user' uses a specific verb ('Get') and resource ('authenticated user'), clearly distinguishing it from sibling tools that retrieve other entities (e.g., bundles, videos, accounts). No ambiguity.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or comparison to related tools like 'tokportal_update_current_user_settings'.

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

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

The description goes beyond annotations by explaining the `code` field behavior: it is null until the manager submits (status `in_review`) or delivers (status `finalized`). This adds meaningful context about return values and asynchronous status, which is not covered by the readOnlyHint or idempotentHint annotations.

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

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

The description is two sentences, front-loaded with the core action, and contains only relevant details about the `code` field and statuses. No wasted words.

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

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

For a simple read-only getter with one parameter and no output schema, the description covers the essential behavior: what it returns, the null condition, and statuses. It is complete for its complexity level.

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

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

The input schema already describes the sole parameter `id` as 'Video ID.' with 100% coverage. The description does not add further semantic detail, but it also doesn't need to since the parameter is self-explanatory and the schema covers it.

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

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

The description clearly states the tool's purpose: 'Get / poll the ad code for a video.' It specifies the resource (video ad code request) and the action (get/poll). It distinguishes from sibling tokportal_create_video_ad_code_request by focusing on retrieval, and clarifies it returns the latest request.

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

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

The description implies when to use this tool (to fetch and poll ad code status) but does not explicitly exclude alternatives or mention any prerequisites. It provides clear context but lacks explicit 'when not to use' guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no additional behavioral context such as return format, permissions, or rate limits, but it is consistent with the annotations.

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

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

The description is four words: 'Get single video analytics.' It is extremely concise, front-loaded with the verb and object, and contains no filler or redundant phrasing.

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

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

While the tool is simple (one parameter, no output schema), the description does not explain what 'video analytics' encompasses or what the response contains. With no output schema and no behavioral detail, the agent may not know whether this returns raw metrics, aggregated data, or a specific format.

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

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

Schema description coverage is 100%, with the single required parameter 'id' described as 'Video ID.' The description does not add extra meaning beyond the schema, but the baseline applies because the schema fully documents the parameter.

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

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

The description uses a specific verb ('Get') and resource ('single video analytics'), clearly indicating the operation targets one video's analytics by ID. The word 'single' distinguishes it from list-style siblings like tokportal_list_account_video_analytics, though it doesn't explicitly name those alternatives.

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

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

No guidance is provided on when to use this tool versus alternatives. The description only states the action without mentioning any exclusions, prerequisites, or contrast with related analytics tools like tokportal_get_analytics_series or tokportal_list_account_video_analytics.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds valuable behavioral context: 'Created tasks remain open until completed; they do not expire,' which goes beyond annotations. However, it does not mention any rate limits or auth requirements, which are not critical given the annotations.

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

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

The description is two sentences long, front-loaded with the purpose, and every sentence adds value. No redundant or irrelevant information.

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

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

Given the tool has no output schema, the description adequately lists the key return components (status, per-term tasks, aggregated report, dispatch details, verification, proof video link) and mentions task persistence. It covers the essential information an agent needs to interpret the output, though a few more details about the report format could be helpful but not necessary.

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

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

Schema coverage is 100% for the single parameter 'id,' which has a description. The tool description does not add further parameter semantics beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool retrieves a specific Advanced Niche Warming session by ID, listing the returned data fields (status, tasks, report). It distinguishes itself from sibling tools like 'tokportal_list_account_warming_sessions' by focusing on a single session retrieval.

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

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

The description implies the tool is used when you have a warming session ID, but it does not explicitly contrast with the list tool or provide guidance on when to use this vs. alternatives. Usage context is inferred 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, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no additional behavioral context such as return format, error handling, or authentication requirements. It simply restates the purpose without enriching what annotations already provide.

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

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

The description is a single, focused sentence with zero extraneous content. It is front-loaded and communicates the core action 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?

Given the simplicity (1 parameter, no output schema, no nested objects) and strong annotations, the description is minimally adequate. However, it omits any statement about what is returned or that it retrieves a single endpoint by ID, which would improve completeness.

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%: the 'id' parameter has a clear description ('Webhook endpoint ID.'). The tool description adds no further meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description clearly states the action ('Get') and the resource ('webhook endpoint'), making the primary purpose obvious. It does not explicitly distinguish from sibling tools like list_webhook_endpoints, but the singular 'a' combined with the 'id' parameter implies single-item retrieval.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of when to prefer this over list_webhook_endpoints or other retrieval tools. Usage context is only implied by the tool name and parameter.

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

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

Annotations are minimal (readOnlyHint false, etc.), so the description carries the behavioral burden. It discloses multiple behavioral traits: coverage checking before media operations, automatic renewal attempts for active periods, and safe abort if renewal fails. This goes beyond simple 'import CSV' to explain potential side effects and preconditions. The description adds significant value beyond annotations.

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

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

The description is concise with 5 sentences covering purpose, process, prerequisites, and edge cases. It front-loads the main action. The complex renewal logic adds necessary depth without being verbose. A small deduction for not starting with a one-liner that immediately distinguishes from siblings.

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

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

Given no output schema, the description explains what happens (import, coverage check, media fetch) but doesn't clarify return value or status. Given the complexity (multipart upload, coverage renewal), the description is fairly complete. It explains preconditions and abort behavior, which is critical for a potentially destructive operation. Slight gap: doesn't mention whether the tool returns a task ID or status.

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 baseline is 3. The description does not add detail about parameter meanings beyond the schema (e.g., 'id' is bundle ID, 'file_path' is the CSV path). It mentions 'uploads a CSV file' which relates to file_path but adds no new constraints or format guidance. The auto_publish and idempotency_key are not elaborated.

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

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

The description clearly states the tool imports video slots from a CSV file, uploads the CSV, downloads media, and configures slots. The verb 'import' is specific, and the resource 'bundle videos CSV' is clear. It distinguishes from sibling tools like 'tokportal_add_video_slots' by emphasizing bulk CSV import rather than individual slot management.

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

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

The description provides context for when to use: when a CSV file needs to be processed for video slots. It implicitly suggests it's not for single-slot operations. It includes coverage prerequisites and renewal behavior for delivered saved accounts, which helps decide whether to use this tool given account state. However, it lacks explicit alternatives or when-not-to-use guidance.

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

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

The tool has strong annotations (readOnlyHint, idempotentHint, destructiveHint false) which already convey safety. The description adds behavioral context by explaining the polling mechanism, lifecycle coverage, and the important distinction that only validated bans are included. No contradiction with annotations.

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

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

The description is dense but concise, packing substantial information into a few sentences. It front-loads the main purpose, then provides lifecycle details, webhook counterpart, filtering caveat, and polling advice—all without wasted words.

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

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

Given the tool has 7 parameters, no output schema, and zero required parameters, the description covers the critical behavioral aspects (lifecycle, polling, validation scope). It lacks explicit mention of return format (e.g., pagination metadata), but for a list endpoint with a page/per_page schema, this is a minor gap. The description is largely 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 100%, so the baseline is 3. The description adds value beyond the schema by explaining the 'since' parameter as a polling watermark, enumerating the lifecycle statuses with their meanings, and describing the resolution filter options with context. This extra guidance justifies above the baseline.

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

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

The description clearly states the tool lists ban reports and appeals, covering the full lifecycle with explicit statuses and resolution codes. It distinguishes itself from sibling tools by specifying its domain (ban reports, not bundles, accounts, videos, etc.) and by noting it is the REST counterpart of specific webhook events.

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

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

The description provides clear guidance on when to poll with the 'since' parameter to pick up updates, and explicitly states that only staff/CM-validated bans appear, while internal health scan detections are never listed. However, it does not explicitly mention when not to use this tool or name alternative sibling tools for related tasks.

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 idempotentHint=true, so the safety profile is clear. The description adds no behavioral details beyond the annotations, such as whether it returns paginated results or requires authentication. With complete annotation coverage, a score of 3 is appropriate as the description doesn't contradict and adds minimal additional 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?

The description is a single, short sentence that directly states the tool's purpose without extraneous detail. It is front-loaded with the key action and resource, making it easy for an agent to parse quickly. However, it could be slightly more informative without adding much length, such as noting pagination or required account ID.

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

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

Given the tool has 4 parameters, no output schema, and complete annotation coverage, the description is minimally adequate. It tells the agent what the tool does but omits details about what the response contains (e.g., list of bundle names/IDs), how pagination works, or that the account must be delivered first. The sibling list is large, and more explicit differentiation would improve completeness.

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

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

Schema description coverage is 100%, so the schema already documents all 4 parameters including their types, defaults, and format (e.g., UUID for 'id'). The description does not add new meaning beyond what the schema provides, such as explaining that 'status' might filter by specific bundle statuses. The baseline of 3 is correct given full schema coverage.

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

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

The description 'List bundles for a delivered account' uses a specific verb ('List') and resource ('bundles for a delivered account'), clearly indicating the tool's function. It distinguishes itself from sibling tools like tokportal_list_bundles by implying a scope limited to a specific delivered account, though it could be more explicit about the distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as tokportal_list_bundles (which may list all bundles). The input schema indicates 'id' is required and it's a delivered account, but there is no explicit statement about prerequisites or exclusions, leaving the agent to infer context from the tool name and sibling list.

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

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

Annotations already declare `readOnlyHint: true`, `idempotentHint: true`, and `destructiveHint: false`, so the agent knows it is a safe, read-only query. The description adds nothing about pagination behavior, rate limits, or return format (no output schema). It does not contradict annotations, but it also doesn't add value beyond them.

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

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

The description is a single sentence, which is appropriately concise. However, it could be slightly more informative (e.g., mention filtering or pagination) without becoming verbose. It avoids wasted words but misses an opportunity to add 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?

Given that there are 5 parameters and no output schema, the description is too sparse. It doesn't explain key aspects like pagination handling, what 'delivered' means in this context, or how to use filters effectively. For a listing tool with rich filtering options, the description should be more 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 100%, and every parameter is well-documented in the schema (e.g., `banned` enum explains values, `country` mentions alias support). The description adds no additional meaning beyond what the schema already provides. Baseline 3 applies because schema coverage is high and no param info is missing.

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

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

The description says 'List delivered accounts,' which is a clear verb+resource combination. It distinguishes the tool as a listing endpoint, but it does not explicitly differentiate it from siblings like `tokportal_get_account` or `tokportal_list_account_bans`, which also deal with accounts. The purpose is clear but not uniquely positioned among siblings.

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

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

The description does not provide any guidance on when to use this tool versus alternatives (e.g., `tokportal_get_account` for a single account, `tokportal_list_account_bans` for bans). It also doesn't mention prerequisites, typical use cases, or limitations. The context of filtering via parameters is implied but not explicitly stated as usage advice.

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 idempotentHint=true, establishing a safe read operation. The description adds minimal behavior beyond that—only scope ('for an account')—so it adds some value but does not enrich the behavioral context (e.g., pagination behavior, default sorting). No contradictions exist.

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 concise sentence (six words) with no redundant information. It is front-loaded and entirely to the point with zero waste.

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

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

For a list operation with five parameters, the description is minimal. It does not explain the return format (non-existent output schema), nor does it provide a high-level overview of what 'post analytics' entail or how pagination and sorting work together. However, the schema covers detailed parameter semantics, so the description supplements the structured data sufficiently for a basic understanding, though it lacks richer context.

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

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

The input schema has 100% documented parameters with clear descriptions for all five fields. The tool description adds no extra param semantics, which is acceptable given full schema coverage. Baseline 3 is appropriate; the schema carries the explanatory burden.

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

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

The description clearly states the action ('List') and resource ('post analytics for an account'), matching the tool name and distinguishing it from the related 'get_video_analytics' sibling (which likely targets a single video). It is specific and unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. While the 'list' verb implies it for paginated retrieval, there is no mention of exclusions (e.g., using get_video_analytics for a specific video) or prerequisite conditions. The sibling tools include many related analytics endpoints, so this distinction is not clarified.

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

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

Annotations already provide readOnlyHint, idempotentHint, destructiveHint, so the safety profile is clear. The description adds valuable beyond-annotation behavior: sessions listed newest first, tasks unlock over 3 calendar days in the manager's timezone, and tasks do not expire. No contradictions.

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 sentences, front-loading the purpose and then adding key details. It is efficient with no filler, though a bullet or structured list could improve scanability slightly.

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

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

Given no output schema, the description covers return contents (tasks, reports, proofs, aggregated report) and ordering. It also explains temporal behavior (3-day unlock, no expiration). Missing pagination details but still sufficient for a list tool with idempotency annotations.

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

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

The schema has 100% coverage and describes the single parameter ('Saved account ID') adequately. The description does not add new parameter-level insight beyond restating 'for a saved account you own'. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'List' and the resources 'Advanced Niche Warming sessions for an account', distinguishing it from sibling tools like tokportal_get_warming_session (single session) and other list tools. It further specifies included data (per-term tasks, reports, proof links, aggregated report), leaving no ambiguity.

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

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

The description implies usage context by stating it lists sessions for 'a saved account you own', but it does not explicitly compare to alternatives or state when not to use it. Siblings like tokportal_get_warming_session exist but are not mentioned. The guidance is implicit, not directive.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds no additional behavioral context (e.g., pagination behavior, ordering, or whether comments are returned in a specific format). With annotations covering the core safety traits, a 3 is appropriate as the description adds minimal extra value.

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, concise sentence that is front-loaded with the core purpose. It is efficient and free of fluff, though it could be slightly more informative without becoming verbose.

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

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

Given the tool's moderate complexity (4 parameters, no output schema), the description is adequate but not complete. It does not explain the return structure, pagination behavior, or how the parameters interact (e.g., postId vs trackedPostId). The annotations and schema cover the basics, but the description could provide more context for a fully informed invocation.

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

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

Schema description coverage is 100%, so all four parameters (id, limit, postId, trackedPostId) are documented in the schema. The description does not add any additional meaning beyond what the schema provides, so the baseline of 3 applies. No extra context about parameter relationships or usage is given.

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 'List comments for an account post' clearly states the action (list) and resource (comments for an account post). It is specific enough to distinguish from sibling tools like tokportal_list_comment_tasks or tokportal_get_comment_pulse, though it could be more explicit about the scope (e.g., all comments or filtered).

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

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

The description implies usage for retrieving comments on a post but does not provide explicit guidance on when to use this tool versus alternatives like tokportal_list_comment_tasks or tokportal_get_comment_pulse. No exclusions or alternative tool mentions are given, so it meets the baseline but lacks clear differentiation.

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 readOnly/idempotent/non-destructive behavior. The description adds owner-scoped scope and tier restriction, which is helpful, but it does not disclose behavior like pagination, ordering, or failure modes. No contradiction with annotations.

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

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

Three brief sentences, each carrying relevant information: what it lists, what it returns, and the tier restriction. No filler or repeated schema content.

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

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

For a list tool with full schema coverage and safety annotations, the description sufficiently covers purpose, scope, and access restriction. It does not describe response shape or filter interactions, but this is not explicitly required by the output-schema rule, and the core selection criteria are present.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters. The description adds no parameter-specific meaning; this matches the baseline expected when the schema is complete.

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 the exact operation ('List raw account analytics snapshots') and specifies the returned resource as 'owner-scoped stored raw analytics payloads for a saved account'. This clearly distinguishes it from post-level snapshot siblings like tokportal_list_analytics_post_raw_snapshots.

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 useful context: it is for saved accounts, returns owner-scoped stored raw payloads, and is restricted to 'Full analytics tier only'. However, it does not explicitly name alternatives or state when not to use this tool versus other analytics listing tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the 'owner-scoped' and 'Full analytics tier only' constraints, which are useful behavioral context beyond the annotations. It doesn't describe pagination or response format, but with annotations covering the core safety traits, 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?

The description is two sentences with zero waste. It front-loads the core purpose and adds the key constraint ('Full analytics tier only') in the second sentence. Every word earns its place.

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

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

For a read-only list tool with 100% schema coverage and no output schema, the description is adequate but not rich. It covers the purpose and a key prerequisite, but doesn't mention pagination behavior, sorting, or what the raw payloads contain. Given the tool's moderate complexity (5 params, no output schema), a 3 is fair.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters. The description adds no additional parameter semantics beyond what the schema provides, so the baseline 3 is correct. The 'from' and 'to' date-time parameters are implied by the snapshot listing context but not elaborated in the description.

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

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

The description clearly states the tool lists raw post analytics snapshots, specifying it returns owner-scoped stored raw analytics payloads for a tracked post. It distinguishes from sibling tools like tokportal_list_analytics_account_raw_snapshots by focusing on 'post' rather than 'account', though it doesn't explicitly name the alternative.

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

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

The description implies usage for retrieving raw analytics snapshots for a tracked post, and the 'Full analytics tier only' note provides a prerequisite. However, it doesn't explicitly state when to use this over the account-level snapshot tool or other analytics tools, nor does it mention any 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, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. However, the description adds no behavioral context beyond 'List', such as pagination defaults (though half the parameters are pagination-related), result ordering, filtering behavior, or rate limits. The description fails to leverage the opportunity to add value beyond annotations.

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

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

While the description is short (2 words), it is under-specified rather than efficiently informative. It does not earn its place; it merely echoes the tool name. True conciseness would front-load key context (scope, filtering, pagination) without redundancy. This is closer to a placeholder than a crafted summary.

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 7 optional parameters (including pagination and multiple filters) and no output schema, yet the description offers no context about the entity 'bundle', the response structure, or how filters interact. An agent cannot infer whether this lists all bundles or scoped to a context. Without additional context, the description is incomplete for a listing tool with such richness.

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%, meaning each parameter has a basic description in the schema (e.g., 'Page number.', 'Filter by bundle status.'). The tool description 'List bundles' adds no additional parameter meaning, interaction hints, or examples. Baseline 3 is appropriate as the schema carries the burden, but the description doesn't compensate for any gaps.

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

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

The description 'List bundles' is nearly a tautology of the tool name 'tokportal_list_bundles'. It states a verb and resource but adds no specificity about what a 'bundle' is, the scope of listing, or how it differs from siblings like 'tokportal_list_account_bundles' or 'tokportal_list_bundle_videos'. Purpose is marginally clear but not enriched beyond the name.

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

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

The description provides no guidance on when to use this tool versus alternatives. With over 60 sibling tools including several list and get operations, the absence of any usage context makes it hard for an agent to select this tool correctly. No when-to-use or when-not-to-use information is 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, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no extra behavioral context (e.g., pagination, ordering, or what 'slots' means), but with annotations present this is acceptable. No contradiction with annotations.

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

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

The description is a single, concise sentence with no filler. It front-loads the action and resource clearly, making it maximally efficient.

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

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

For a simple one-parameter list operation with annotations, the description is mostly adequate. However, the tool name says 'videos' while the description says 'slots', which could confuse agents about what exactly is returned. No output schema or additional context is provided, so completeness is slightly compromised.

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% with a single parameter 'id' described as 'Bundle ID', which is clear. The tool description itself does not add meaning beyond the schema, but the schema does the heavy lifting, so a baseline of 3 is appropriate.

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

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

The description 'List bundle video slots' uses a specific verb and resource, clearly distinguishing it from sibling tools like 'tokportal_get_bundle_video' (retrieves a single video) and 'tokportal_list_bundles' (lists bundles). The action is unambiguous and actionable.

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

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

The description provides no guidance on when to use this tool compared to alternatives. It does not mention any exclusions, prerequisites, or related tools, leaving the agent to infer usage solely from the 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, idempotentHint=true, and destructiveHint=false, which cover safety. The description adds specific behavioral details beyond annotations: the meaning of execution_blocked and execution_block_reason, and that reads remain available even when execution is paused. This is valuable context not available in the schema or annotations, enhancing transparency without contradicting them.

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

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

The description is exceptionally concise: two sentences, front-loaded with the primary purpose ('List comment tasks') followed by a specific, non-redundant detail about the execution_blocked fields. Every word earns its place, with no filler or repetition. It efficiently conveys the core function and a key operational nuance.

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

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

The description covers the core operation and a notable edge case (paused tasks), but it omits any mention of return structure or pagination behavior (though pagination is implied via page/per_page in the schema). Since there is no output schema, the agent might benefit from a note about response format, but for a list operation with well-documented parameters, the description is minimally adequate. It does not fully compensate for the absence of output schema details.

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

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

The input schema has 100% description coverage for all four parameters (page, status, per_page, saved_account_id), so the description is not required to explain them. The description does not add any parameter-specific semantics beyond what the schema already provides, which is acceptable given high coverage. No additional meaning is contributed, so a baseline of 3 is appropriate.

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

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

The description clearly states 'List comment tasks' and specifies it lists 'owned comment tasks', distinguishing it from related tools like tokportal_get_comment_task (single task) and create/delete/approve tasks. The phrase 'Lists owned comment tasks' makes the scope explicit, providing a precise verb+resource+scope definition.

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