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

Annotations already indicate destructiveHint: true, so the description doesn't need to restate that. It adds minimal context by specifying the identifier. No mention of whether cancellation is reversible or if there are side effects, but with destructiveHint present, a 3 is reasonable.

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

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

One sentence, front-loaded with the action and the key parameter. No fluff, though it could specify the type of job_id (e.g., string) but that's in schema.

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

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

For a single-parameter action with destructive annotationable, the description is adequate. It doesn't explain return values, but output schema exists, so that's covered. Missing when to use and potential error cases, but given simplicity, average.

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 has 1 param with 0% description coverage)Skip. The description states that job_id is used to cancel, which adds the context that jobId is a job identifier, but it's already implicit in the param name. The description adds minimal meaning beyond the name.

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

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

Clearly states it cancels a scheduled post, identified by job_id. The verb 'cancel' and resource 'scheduled post' are specific. Though similar to edit_scheduled, it distinguishes itself by the action of cancellation.

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 versus edit_scheduled or retry_post. No mention of prerequisites like needing a valid job_id or that the post must be in scheduled state.

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

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

Annotations only mark readOnly=false and destructiveHint=false; the description adds meaningful behavioral disclosure: every action has an inverse so nothing is permanent, unsupported networks return 400 platform_not_supported, and TikTok capability must be present and reconnected if not granted. This is useful context that the annotations do not 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?

Every sentence earns its place: first line summarizes purpose, then error behavior, inverses, parameter constraint, sibling separation, and the TikTok caveat. The structure is logical and front-loaded with the core action taxonomy.

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

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

Despite the complexity (six actions, network-specific behavior, capability requirements), the description covers the error contract, inverse semantics, parameter constraints, TikTok special case, and sibling differentiation. The presence of an output schema means return-value documentation is not needed, so nothing important is missing.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description reinforces and sharpens the postId constraint by saying it 'must NOT be sent' for like/unlike, which is stricter than the schema's 'not used.' It mostly restates the schema's parameter descriptions, so it adds only a moderate amount beyond the schema.

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

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

The description opens with a specific verb phrase: 'Moderate or react to a comment' and enumerates the concrete actions (hide, like, pin), which clearly identifies the resource and scope. It also explicitly separates itself from delete_comment, so the agent can distinguish this tool from comment-management siblings.

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

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

It states when to use it (actions on one of the profile's own posts) and explicitly names delete_comment as the different tool for deletion. It adds actionable conditions: postId is required for hide/unhide and pin/unpin and must NOT be sent for like/unlike, and TikTok requires the 'comments' capability, with a reconnect instruction. This goes beyond merely implying context.

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

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

Annotations already cover the mutation profile (readOnlyHint=false, destructiveHint=false). The description adds useful behavioral context beyond those annotations: the hard dependency on the preceding PUT request, the fact that it will fail or produce unusable media without that step, and the temporary nature of the returned URL. This is meaningful situational 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 three short, front-loaded sentences: step identity, call precondition, and output usage. There is no filler or redundancy, and the complexity is low. It uses a compact, informative structure rather than burying details; a 5 may be one sentence too lean, but this is already 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 single-parameter tool with an output schema, the description covers the essential context: the step position, the required precondition, failure scenario, return value, and downstream consumers. It does not detail timeouts, retries, or auth, but those are likely shared across the API and not necessary for an agent to call this tool correctly.

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

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

Schema coverage is 100% and uploadId is well-documented as 'upload_id returned by create_media_upload.' The description adds additional semantic constraint not visible in the schema: the uploadId must correspond to an upload whose bytes were actually PUT to the upload_url. This helps the agent reason about valid values beyond the schema's type and origin.

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 tool's role as 'Step 2 of staging a local file' and describes the return value ('temporary media_url'). It distinguishes itself from sibling tools like create_media_upload (step 1) and upload_video/upload_photos/upload_document by positioning the result as the input to those upload tools, giving it a specific verb-resource pairing.

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

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

The description gives an explicit conditional: 'Call it only after the file bytes were actually PUT...' and states the failure consequence if that precondition isn't met ('fails or yields no publishable media'). It also provides the downstream usage by naming the three upload tools to pass the returned media_url to, making the intended workflow 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?

Discloses a non-obvious operational requirement beyond the annotations: TikTok requires the 'comments' capability, it is granted at connection time, and older accounts must reconnect. This is exactly the type of behavioral context an agent needs and it does not contradict readOnlyHint=false or destructiveHint=true.

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

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

Every sentence earns its place: purpose, target exclusivity, per-platform rules, and auth prerequisite. The description is dense but well organized and contains no filler.

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

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

Covers cross-platform variations, parameter relationships, and an authentication edge case. With an output schema present and annotations already indicating the safety profile, nothing essential is missing for an agent to invoke this tool correctly.

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

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

Even though the schema has 100% coverage, the description adds genuinely new meaning: exactly one of commentId/postId/postUrl must be chosen, Instagram only accepts replies, TikTok always requires postId, and postId+commentId can be combined for TikTok thread replies. This goes well beyond the bare schema definitions.

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

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

The description opens with a specific action ('Post') and clearly identifies two modes: top-level comments (via postId/postUrl) and replies (via commentId). Platform-specific notes further disambiguate it from sibling comment tools like reply_to_comment.

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 strong within-tool guidance: exactly one target parameter, Instagram's reply-only restriction, TikTok's postId requirement, and the TikTok capability prerequisite. However, it does not explicitly mention sibling alternatives such as reply_to_comment or comment_action, leaving the when-to-use-this-versus-that decision slightly implicit.

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

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

Annotations are minimal, so the description carries the burden. It discloses the short-lived upload_url, the requirement to PUT raw bytes with matching Content-Type and size, the 24-hour staging deletion, and the safety of scheduled posts via upload_video copying to durable storage. No contradiction with readOnly/destructive hints.

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

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

Three dense sentences with no filler: purpose first, then return value and required workflow, then when not to use, then lifecycle/durability. 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?

Covers return values, next steps, constraints, TTL, and exception path. Given the output schema fills in exact response shape, nothing critical is missing for an agent deciding to call this tool.

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

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

Schema already documents filename, contentType, and contentLength well, so the baseline is 3. The description adds meaningful behavioral context by requiring that the subsequent PUT uses the same Content-Type and size declared in these parameters, which is valuable 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?

Clearly identifies itself as 'Step 1 of staging a local file for publishing', states what it returns (upload_id, short-lived upload_url), and distinguishes itself from complete_media_upload and upload_video. An agent can immediately understand its role in the workflow.

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

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

Explicitly states when it is useful (client can perform HTTP PUT), when it is not (model cannot read chat attachments or /mnt/data paths), and gives concrete alternatives (ask for a public HTTPS URL or send to app.upload-post.com). Also names the required follow-up call.

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

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

Annotations declare readOnlyHint false and destructiveHint false, which align with the description's 'Create' action. The description adds context that the profile is a logical container for connected socials, providing some behavioral clarity beyond the annotations. However, it does not disclose side effects, permissions required, or whether the operation is reversible, but given the annotations already cover the safety profile, the bar is lower and 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 a single, well-structured sentence that immediately conveys the core purpose without any fluff. It front-loads the action and resource, and the clarifying parenthetical adds value without redundancy. Every word earns its place, making it exceptionally concise 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?

Given the tool's low complexity (only one parameter) and the presence of an output schema (which presumably documents the return value), the description covers the essential concept of what a profile is. It explains that it is a logical container, which is helpful for an agent to understand the abstraction. However, it leaves out details like whether username has any validation rules or if there are any side effects on connected socials, but these are minor for such a simple operation.

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

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

The schema description coverage is 0%, and the description does not mention the 'username' parameter at all. While the parameter is simple (a string), the description provides no additional meaning, such as format, uniqueness constraints, or any examples. Since the schema itself only gives the type and required status, the description fails to compensate for the lack of coverage, resulting in minimal semantic enrichment.

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

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

The description clearly states the action ('Create a new Upload-Post profile') and specifies the resource type. It distinguishes itself from sibling tools by naming a specific concept (logical container for connected socials), which is unique among the listed siblings. However, it could elaborate a bit more on what 'profile' entails beyond the container metaphor, so it does not reach a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites, exclusions, or conditions. While the name 'create_user' implies a clear use case, there is no explicit context about when not to use it or how it fits with related tools like 'list_users' or 'delete_user'. The description assumes the agent will infer usage 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 mark destructiveHint=true and readOnlyHint=false, so the description adds useful context: the LinkedIn postId dependency, the TikTok capability requirement, and the fact that older connections must be reconnected. This goes beyond the annotations and informs the agent about potential failure conditions.

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 concise sentences, front-loading the primary action and then efficiently addressing platform-specific requirements. No redundant wording; each sentence adds necessary 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 has an output schema, so return details are not needed. The description covers the main prerequisites (postId for LinkedIn, TikTok capability) and the need for reconnection. It is sufficiently complete for an agent to execute the deletion correctly, though it doesn't detail behavior for other platforms, which is likely fine.

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 clear per-parameter descriptions. The description adds value by explicitly clarifying that postId is only needed for LinkedIn and commentId is the core ID, reinforcing platform-specific usage and the TikTok capability prerequisite, which is not purely schema-level.

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 'Delete' and resource 'comment' by `commentId`. It distinguishes from sibling tools like get_post_comments, reply_to_comment, and create_comment by focusing on deletion. The platform-specific nuance is highlighted, making it 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 clear operational context (e.g., LinkedIn requires postId, TikTok requires a capability) but does not explicitly state when to use this tool vs. alternatives or mention exclusions. It implies usage by the nature of the action but lacks direct comparative 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 mark destructiveHint=true, and the description adds valuable scope beyond that: it deletes only the short-lived R2 staging upload and leaves later scheduler copies intact. This precise what-gets-destroyed disclosure is exactly the kind of behavioral context agents need for a destructive tool.

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

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

Two tight sentences front-load the key context ('Internal/app staging helper') and state purpose plus a critical exclusion with no wasted words. Every sentence earns its place.

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

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

For a one-parameter destructive tool with an output schema, the description covers the essential context: what is deleted, where it comes from, and what is explicitly not deleted. An agent has enough information to decide whether to call it and what the uploadId refers to.

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

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

The schema has 0% description coverage and only names uploadId as a string. The description's mention of deleting a media upload implies uploadId identifies that staging upload, but it does not explicitly explain where the ID comes from or any constraints. The single self-explanatory parameter softens the gap.

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

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

The description uses a specific verb and resource: 'Delete a short-lived MCP staging media upload from R2.' It clearly distinguishes itself from siblings like upload_video by stating it does not delete scheduler durable copies. This makes the tool's purpose and scope 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 clear context as an 'Internal/app staging helper' and explicitly states a when-not: it does not delete scheduler durable copies created later by upload_video. It does not name an alternative deletion tool for durable copies, so it stops short of fully explicit alternative routing.

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

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

The destructiveHint annotation is present, but the description adds meaningful behavior beyond it: deletion is permanent and also disconnects the profile's connected social accounts. This gives the agent a clearer picture of the side effects without relying on annotation defaults.

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

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

A single, front-loaded sentence that contains no filler. Every word contributes: 'permanently' communicates irreversibility, 'delete a profile' states the purpose, and 'disconnect its socials' describes an important side effect.

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

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

For a one-parameter destructive tool with an output schema, the description communicates the core action, irreversibility, and the social-disconnect side effect. It does not mention cascading data deletion or authorization requirements, but the tool is simple enough that this is still nearly complete.

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

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

Schema description coverage is 0%, so the description must compensate for underdocumented parameters. It does not explain what 'username' refers to or what constraints or formats apply, leaving the agent with only the parameter name to infer meaning.

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

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

The description states a specific action ('permanently delete') on a clear resource ('profile') and adds a distinguishing side effect ('disconnect its socials'). It is easily distinguished from siblings like delete_comment, unpublish_post, and delete_media_upload.

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 say when to choose this tool over alternatives, nor does it mention any preconditions for deleting a user. When it should be used is only inferred from the tool name and purpose statement.

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 readOnlyHint=true and destructiveHint=false already in annotations, the description only needs to add extra nuance. It does so by explaining that no streaming through MCP occurs, which is a meaningful behavioral trait beyond a simple read operation. It adds useful context without any 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 a single explanatory sentence that leads with the core purpose, uses precise wording, and avoids extraneous details. It is efficient and well-structured for quick parsing.

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 is a simple read-only operation with one parameter and an output schema exists to describe the returned structure, the description covers the essential facts: what is being returned, for which kind of job, and its non-streaming behavior. The only minor gap is not clarifying any required preconditions (e.g., that job must have succeeded), but 'completed' mitigates this.

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

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

Schema coverage is 0%, so the description must compensate for the undocumented jobId param. It refers to a 'completed FFmpeg job', which strongly implies jobId is the job identifier, but it never explicitly names or formats the parameter. The description adds marginal meaning but not as explicitly as it could.

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 ('Returns'), the resource ('download URL and metadata for a completed FFmpeg job'), and adds a key differentiator: 'without streaming the processed file through MCP'. This distinguishes it from sibling tools like get_ffmpeg_job or submit_ffmpeg_job with 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 specifies that the tool is for a 'completed' FFmpeg job, providing a clear prerequisite. It also hints at an alternative behavior by indicating it does not stream, but it stops short of explicitly naming sibling tools like get_ffmpeg_job or other streaming-oriented tools, so no clear 'when-not-to-use' is 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?

Descriptions adds modest context beyond the destructiveHint annotation by saying exactly what changes (date and/or timezone). It does not describe side effects, whether existing values are overwritten, or how missing fields are handled, but the annotation already signals mutation.

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

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

A single, front-loaded sentence states the action and the scope of the change with no filler. It is appropriately sized for a simple rescheduling tool.

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

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

The tool is simple, has an output schema, and has annotations that signal mutation, which reduces the description's burden. Still, the required jobId is not explained and no date/timezone format guidance is given, so an agent has to infer some important invocation 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 0% description coverage, so the description must carry parameter meaning. It explains timezone and scheduledDate, but does not clarify jobId, which is the only required parameter, nor does it give format or constraint details for the date/timezone strings.

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

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

The description states a specific action ('Reschedule') and resource ('a post'), and narrows the scope to changing date and/or timezone. This clearly distinguishes it from siblings like cancel_scheduled and list_scheduled, even without naming them.

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

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

The phrase 'Reschedule a post' implies when to use the tool: when an agent wants to change an existing scheduled post's date or timezone. However, it does not explicitly contrast with alternatives like cancel_scheduled or state any prerequisites, leaving usage guidance implied rather than explicit.

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

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

Annotations provide only generic hints (not read-only, not destructive, not open-world). The description adds that the tool returns a JWT and connection URL and is used in an embedded flow, but doesn't disclose side effects such as token expiration, session creation, or whether it persists state. This is acceptable for a token-generation tool but leaves behavioral details to the agent's assumptions.

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

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

Single sentence with no filler; the core action and purpose are front-loaded. It earns its place without 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?

Despite an output schema and nested objects, the description is too thin for an 11-parameter tool with 18% coverage. It omits prerequisites (e.g., username), how to select platforms, or how the returned URL is used, so an agent would struggle to construct a correct call beyond the single required parameter.

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

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

With only 18% schema description coverage, most parameters (username, platforms, redirectUrl, etc.) are undocumented in the schema, and the description adds no parameter-level meaning. It only hints at the high-level purpose (connecting socials), so the agent has no guidance for the many undefined 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 states a specific action ('Generate a JWT + connection URL') with a concrete resource and purpose (letting an end-user connect socials in an embedded Upload-Post flow). It clearly distinguishes this from sibling validate_jwt and upload_* tools by positioning it as token generation for a white-label integration.

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

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

The description gives a clear intended-use context: it is for end-users connecting socials inside an embedded white-label Upload-Post flow. However, it doesn't explicitly contrast with validate_jwt or state when not to use it, leaving some routing to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that it validates the current API key and returns account information, which is useful 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?

Two compact sentences: the first states what the tool does and the second gives its intended use. No filler or repetition; the most important action is front-loaded.

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

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

For a zero-parameter read-only tool with an output schema, the description fully covers when to invoke it and what it does. Nothing needed for correct invocation is missing.

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

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

The tool has zero parameters白白留下，so there is no parameter detail to add. Baseline 3 applies because the description adds no hidden parameter behavior beyond what the empty schema already makes obvious.

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 plus outcome: 'Validate the current API key and return account information.' It clearly identifies the tool's function and differentiates it from sibling tools like validate_jwt or get_history by tying validation to the API key and account data.

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

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

Explicitly recommends use as a first call before real work, giving clear contextual timing. It does not mention alternative tools or exclusion cases, but the use-case guidance is sufficient for a simple tool.

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

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

Annotations already declare read_only_hint=true and destructive_hint=false, so the description need not restate that. The description adds valuable behavioral context by disclosing that Instagram returns two audience breakdowns with a specific shape (`follower_demographics` and `engaged_audience_demographics`), which is not evident from annotations or schema. This goes beyond the read-only hint to explain a platform-specific output variation. 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, well-structured sentence that front-loads the core purpose and tacks on a relevant platform-specific note. There is no redundant wording or filler. It is concise while still conveying important contextual detail.

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

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

With an output schema present, the description need not detail return values. It covers the main behavior and the notable Instagram-specific breakdown, which is the only non-obvious output detail. The schema covers parameter constraints (e.g., LinkedIn pages must be administered), so the description is sufficiently complete for an agent to invoke the tool correctly.

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

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

Schema description coverage is 50%, with pageId and pageUrn having descriptions but profileUsername and platforms lacking them. The description indirectly explains platforms as 'selected platforms' and mentions Instagram-specific output, but it does not add syntax or meaning for profileUsername or clarify the platforms array beyond what the enum already provides. It partially compensates for the coverage gap but not fully.

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

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

The description clearly states it provides aggregated analytics for a profile across selected platforms, listing specific metrics (followers, views, engagement). It distinguishes from sibling tools like get_post_analytics (post-level) and get_platform_metrics (platform-level) by explicitly targeting profiles. The verb and resource are unambiguous.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. It does not mention that for post-level analytics one should use get_post_analytics, or that get_cached_post_analytics might be more efficient. The phrasing 'across selected platforms' implies filtering but provides no usage context.

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

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

Annotations already mark the tool as read-only (readOnlyHint=true) and non-destructive (destructiveHint=false), so the description does not need to repeat that. It goes well beyond annotations by disclosing the server-side window clamping ('at most 60 days, always ending before today – a wider range is trimmed, not rejected'), the benchmark behavior (always returns the 25 accepted values, and adds a benchmark object when a category is set), and the capability requirement. These are significant behavioral details that an agent would not know otherwise, making the tool's runtime behavior fully transparent.

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 relatively long but every sentence carries information. It is front-loaded with the core purpose, followed by return fields and specific behavioral notes. The structure is logical and avoids redundancy. It could be slightly more concise (e.g., the capability note could be trimmed), but it is not verbose or repetitive. The density of useful facts justifies a 4, as it is more than minimal but still efficient.

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

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

Given that the tool has an output schema (so return value details are covered elsewhere), the description covers all critical aspects an agent needs: the purpose, the response structure (list of keys), the benchmark behavior, the clamping behavior, and the prerequisite capability. It even explains how to discover valid benchmark categories (omit the parameter). There are no missing pieces that would prevent a correct invocation or interpretation. The description is complete for its complexity.

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

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

Schema description coverage is 100%, so the baseline for this dimension is 3. The description adds meaningful semantics beyond the schema: for benchmark_category it explains 'Must be one of the benchmark_categories the response lists; omit it on the first call to read them,' which is crucial usage guidance not present in the schema. It also clarifies endDate clamping and that platform values are constrained to an enum (though schema already lists that). The additional explanation of the interplay between benchmark_category and the response's benchmark_categories adds real value, so a 4 is warranted.

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

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

The description begins with a precise, specific statement of what the tool does: 'Who follows the profile, when they are online and what they tap on it.' It clearly identifies the resource (profile audience) and the action (retrieving insights). It also notes it's a single endpoint for every network selected via 'platform', which distinguishes it from generic analytics tools. The level of detail about return fields (audience.countries, activity_by_hour, etc.) leaves no ambiguity about the tool's purpose.

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

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

The description gives clear context on when to use the tool—when you need audience composition, activity patterns, or benchmark comparisons. It also provides a critical prerequisite: 'Requires the 'profile_analytics' capability on the profile's TikTok account,' which is a form of usage constraint. However, it does not explicitly name alternative tools or state 'use X instead when you need Y,' leaving some inference to the agent. It is still clear and actionable, so a 4 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?

Beyond the readOnly annotation, it discloses important behaviors: no background refresh, `captured_at` reflects the last live read, posts not previously fetched are absent, and the tool is exempt from the live rate limit. It also documents pagination behavior (`next_cursor`/`has_more`) in the description, which is not visible in the schema annotations alone.

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

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

Three sentences carry the full load: purpose, cache freshness, rate-limit advantage, and pagination. Every clause earns its place — no filler or schema duplication. The purpose is front-loaded, and the comparison to the sibling comes early enough for fast decision-making.

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 output schema exists and the parameter schema covers everything, the main risks for an agent are misunderstanding that this is cached and lacks fresh data, and not knowing when to avoid it. The description fully addresses these, and also provides the pagination loop, the absence of refresh, and the `captured_at` meaning. No critical behavior remains unexplained.

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

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

The schema already describes all six parameters at 100% coverage, including defaults, max values, formats, and enums. The description adds semantic value beyond the schema by using the `cursor` contract (`next_cursor` from response back as `cursor` until `has_more` is false), which directly clarifies how the pagination parameter should be used in practice.

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

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

The description opens with the specific verb-reource pair: 'Replays per-post metrics Upload-Post already fetched' and immediately distinguishes the tool from the live `get_post_analytics` by noting it does not hit platforms again. It also explains the scope ('ONLY contains posts previously fetched'), so an agent can tell precisely what this tool returns and how it differs from siblings without opening the schema.

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

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

It explicitly tells agents when to prefer this tool: 'prefer it when scanning many posts or paging through a profile's history' and names the key difference from `get_post_analytics` — no platform calls and no rate limit. It also warns about the limitation ('a post never queried live will be absent'), which implicitly tells the agent when to choose the live variant instead.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile, so the bar is lowered. The description adds the scoping fact that pages are 'connected to a profile' but discloses nothing further — behavior when the optional profile parameter is omitted, pagination, or failure conditions. It does not contradict the annotations, but contributes little 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?

Six words, efficient and front-loaded, but the brevity veers toward under-specification. The single noun phrase carries only the resource and a vague scope; it earns its place but does little informational work beyond the name and title.

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

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

The tool is simple (one optional parameter, no enums) and an output schema exists, so return values need not be explained. The critical gap is the profile parameter: 0% schema coverage and no description of how to supply it, though its optionality means the tool can still be invoked with no arguments. Adequate for tool selection, thin for correct invocation with the parameter.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented profile parameter. The phrase 'connected to a profile' merely echoes the parameter name and gives no indication of accepted values, format, or how to identify a profile. It adds marginal meaning but leaves the only parameter effectively undocumented.

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

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

The description names a concrete resource (Facebook pages) and a scope ('connected to a profile'), and the resource name clearly distinguishes it from platform siblings like get_linkedin_pages and get_pinterest_boards. However, the description itself is a noun phrase with no explicit verb — 'List' appears only in the title — and 'Facebook pages connected to a profile' borderlines on restating the name.

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

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

There is no guidance on when to use this tool over alternatives. With a large sibling set containing many similar list tools (get_linkedin_pages, get_pinterest_boards, get_google_business_locations), the description provides no conditions, exclusions, or alternative routing. The agent is left to infer usage solely from the resource 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 indicate a read-only, non-destructive operation. The description adds useful semantic context that this is a monthly plan-allowance comparison rather than a per-job status lookup. For a simple quota getter, this is sufficient 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?

Single sentence, front-loaded with the key concept 'monthly FFmpeg processing minutes used vs. plan allowance'. No fluff, no repetition of the tool name.

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

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

For a zero-parameter read-only quota tool, the description plus readOnlyHint and an output schema is largely complete. It clearly identifies the metric and comparison. It does not explicitly state when to prefer this over get_ffmpeg_job, but the quota-vs-job distinction is strongly implied by the wording.

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 accepts zero parameters, so no parameter explanation is needed. The description adds meaning to what the tool reports (monthly usage vs. allowance), fully covering the no-parameter case.

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

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

The description clearly states a specific read-only purpose: report monthly FFmpeg processing minutes used versus the plan allowance. It is unambiguous and distinct from sibling tools like get_ffmpeg_job, which concerns individual jobs, not consumption.

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 about when to use this tool versus alternatives such as get_ffmpeg_job or submit_ffmpeg_job. The context is clear from the description, but the description does not help an agent choose between related tools or rule out alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=falseikuha. The description adds that the job reaches a 'completed' status and that the result is fetched via a separate call, which is useful. It doesn't disclose potential edge cases (e.g., failure states, whether polling consumes resources), but for a simple read-only poller this is acceptable.

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

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

Two tightly written sentences. The main action is front-loaded and the follow-up action is included without fluff.

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

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

For a one-parameter, read-only polling operation with an output schema, this is nearly complete. The only missing piece is the jobId source or format, but the schema and title carry that weight.

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

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

Schema description coverage is 0% for the jobId parameter. The description never mentions jobId's format, origin, or how to obtain it. The name 'jobId' is self-evident, but the description adds no parameter-level value.

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

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

The description uses a specific verb ('Poll') plus a specific resource ('FFmpeg job status'), and the title reinforces it. It distinguishes this tool from the generic sibling get_job_status by naming the exact domain (FFmpeg).

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

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

It gives clear context for the status result and directs the caller to download_ffmpeg_result when status is 'completed'. However, it doesn't explain when to prefer this over generic alternatives like get_job_status, nor does it say how frequently to poll.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to restate safety. It adds one useful behavioral detail: only postable locations are returned. It does not describe behavior when profile is omitted or responses are empty, but the annotation coverage lowers the 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?

One short front-loaded sentence with no redundancy. Every word contributes to the tool's purpose and scope.

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 one-parameter tool, available output schema, and strong annotations, the description is reasonably sufficient. However, the parameter semantics and usage guidance are thin enough that an agent might not know how to populate 'profile' or when to prefer this tool over sibling list tools.

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

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

Schema description coverage is 0%, so the description must compensate for the single 'profile' parameter. It weakly clarifies the parameter by referring to 'the profile can post to,' but it does not explain how it should be specified, whether it is required, or what values it accepts.

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 identifies the resource (Google Business Profile locations) and scopes it to 'the profile can post to,' which makes it distinct from sibling get_google_business_reviews. Although the description is a noun phrase rather than a verb phrase, the title supplies the action '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?

There is no explicit guidance on when to use this tool versus alternatives, nor any exclusion such as 'for reviews, use get_google_business_reviews.' The phrase 'can post to' implies use in a posting workflow, but the agent is left to infer the context.

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

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

Annotations already mark it read-only and non-destructive. The description adds one useful behavioral detail: location_id defaults to the account’s selected location. It does not mention pagination, result scope, or any rate-limit/auth implications.

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

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

Two short sentences, front-loaded with the core action, and no filler or repetition of schema fields.

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

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

With an output schema and read-only annotations present, the description covers the core invocation, required owner, and default location behavior. Minor gap: no explicit pagination guidance, but this is partially inferable from the parameters.

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

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

Schema coverage is decent; the description adds meaning by clarifying that the profile passed must be the owner of the connected account and that omitting location defaults to the selected location. It does not fully explain pageToken or pagination 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?

‘List reviews for a Google Business Profile location’ states the action, resource, and scope in one sentence)Skip; the title reinforces it and distinguishes it from reply/update siblings.

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

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

The description implies when to use this tool and gives setup context (‘pass the profile that owns the connected Google Business account’), but it does not explicitly contrast alternatives or state the condition for choosing this over another read tool.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds the pagination behavior and cross-profile scope, but does not disclose ordering, return format, or any additional behavioral constraints beyond the schema's limit.

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

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

The description is a single, front-loaded sentence with zero fluff. It efficiently states the core purpose and scope, making it easy 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?

Even though an output schema exists, the description lacks details about the returned history entries, ordering, or pagination mechanics. It does not explain what fields are available or how to interpret the data, leaving significant gaps for a caller.

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

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

Schema description coverage is 0%, so the description must explain the page and limit parameters. It only mentions 'Paginated' without defining what page and limit mean, their defaults, or how they interact. This is minimal compensation for the lack of schema descriptions.

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

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

The description 'Paginated history of uploads across all profiles' clearly states the verb (get history), resource (uploads), and scope (across all profiles). It distinguishes itself from sibling tools like get_media (specific media) and get_status (job status) without 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 provides no guidance on when to use this tool versus alternatives such as get_media or get_status. There is no mention of exclusions, prerequisites, or typical use cases beyond the bare statement of function.

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 readOnlyHint and destructiveHint annotations already convey safety, and the description adds meaningful context by scoping the tool to scheduled/queued upload status checks. It clarifies the input’s origin (posts created via `addToQueue` or `scheduledDate`), which exceeds what annotations alone indicate.

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

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

Two sentences, no filler, with the primary purpose front-loaded. Every word contributes to clarifying what the tool does and when to use it.

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

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

For a single-parameter read-only lookup with an output schema, the description provides necessary context about the resource type (scheduled/queued uploads) and the relevant posting flows. It is slightly incomplete in not mentioning how a jobId is obtained from related tools like `addToQueue` or `list_scheduled`, but not enough to hinder correct invocation.

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

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

With schema_description_coverage at 0%, the description must compensate, and it only says 'by job_id' which is close to the schema's `jobId` field name. It adds minimal value by tying the ID to scheduled/queued uploads, but it does not explain how to obtain a valid jobId or distinguish it from other job ID formats among siblings. Adequate but not strong.

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

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

States a specific verb and resource ('Check the status of a scheduled or queued upload by job_id') and immediately distinguishes it from generic status tools by narrowing scope to uploads created with `addToQueue` or `scheduledDate`. An agent can easily tell this apart from siblings like `get_status` and `get_ffmpeg_job`.

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 usage context by explicitly stating 'Use this for posts created with addToQueue or scheduledDate'. This tells the agent when to choose this tool, though it doesn't name alternatives or exclude other status tools such as `get_status` or `list_scheduled`.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the useful scoping detail that only pages connected to a profile are returned, but it does not disclose auth needs, pagination, or rate limits; that is acceptable 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 a single front-loaded phrase with no filler, and every word contributes meaning. The title supplies the verb, making the combined definition economical and easy to scan.

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

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

For a read-only, one-parameter list tool with an output schema and annotations, the description is largely complete: it gives the resource, scope, and profile relationship. Missing details such as the exact profile identifier format and alternative routing are minor for basic invocation.

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

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

Schema description coverage is 0%, so the description must carry weight; 'connected to a profile' clarifies that the profile parameter identifies whose pages are listed. It does not specify the expected format of the profile value, though the schema's required array already signals that the parameter is optional.

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's verb 'List' combines with the description's resource 'LinkedIn company pages' and scope 'connected to a profile' to state exactly what the tool does. The focus on LinkedIn clearly distinguishes it from sibling tools like get_facebook_pages and get_google_business_locations.

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 use case—retrieving LinkedIn pages for a given profile—but provides no explicit when-to-use guidance, no exclusions, and no mention of alternatives. The agent must infer usage from the resource name and scope.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds the full pagination contract (pagination field names, passing next_cursor back as cursor, and terminal conditions for the last page), which is the meaningful behavioral detail beyond the annotations. It does not mention rate limits or auth expectations, but it adds real value without contradicting the annotations.

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

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

Four sentences, each earning its place: the core operation and types, the platform scope and use case, and the compact pagination contract. It stays front-loaded and avoids repetition of the schema's parameter docs.

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 5 parameters, an output schema, and readOnly/destructive annotations protecting the safety domain, the description is nearly complete: it clarifies the tool's orientation and the only behavioral protocol agents must implement correctly (pagination). Per-platform caveats such as cursor failures on LinkedIn/Discord/Telegram are left to the schema, which is acceptable given the schema's high detail.

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 qualitative baseline is 3. The description adds value by enumerating supported platforms (the 'platform' param has no enum in the schema in the schema) and by explaining how cursor and pagination fit together, which helps agents use the cursor parameter correctly beyond the schema's own 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?

States the specific verb ('Retrieve'), the resource ('recent media from connected social accounts'), the content types (videos, photos, text posts), and the supported platforms. The phrase 'browsing what already exists... before posting more' clearly distinguishes it from the many upload/post/comment sibling tools, even without naming one.

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

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

Provides a clear use-case ('browsing what already exists on a platform before posting more') that orients the agent against posting and media-upload siblings, and it gives explicit pagination steps. It doesn't explicitly state when not to use this tool or name preferred alternatives, so it falls just short of a 5.

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

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

Annotations already establish read-only and non-destructive behavior, so the bar for extra transparency is lower. The description adds useful context about the upload being short-lived and the URL being a fresh temporary URL, which goes beyond the schema. It still doesn't disclose what happens on expiry or when includeUrl is false, but it provides reasonable behavioral color.

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

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

Two compact sentences with no filler. The key purpose is front-loaded, and the optional URL behavior is stated efficiently. Every clause adds meaning.

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

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

Given the output schema exists and annotations cover safety, the description supplies the essential behavioral and parameter semantics. It explains the staging context, the short-lived nature, and the optional URL return. It could mention explicit expiration or null-handling behavior, but nothing critical is missing for correct invocation.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining parameters. It covers uploadId implicitly as the identifier of the upload being queried and includeUrl explicitly via 'Optionally returns a fresh temporary media_url.' The mapping is clear enough for an agent to use both parameters correctly.

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

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

The description states a specific verb and resource: 'Get status for a short-lived MCP media upload.' It further distinguishes this from generic media or status tools by noting it can 'return a fresh temporary media_url for an already-uploaded staging object,' making the resource and behavior 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 phrase 'Internal/app staging helper' gives useful context about intended use, and the short-lived upload description implies this is for checking upload state rather than production media retrieval. However, it does not explicitly mention when to prefer this over siblings like get_media, get_status, or complete_media_upload, nor any usage 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 the tool read-only and non-destructive, so the description correctly does not contradict them. It adds scoping context ('available to a profile'), but no behavioral details about authentication, default behavior, or response characteristics. The description carries some value but stays close to what the annotations imply.

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 compact phrase with no filler words, which is front-loaded and to the point. It is adequately concise, though the brief structure leaves out necessary detail that other dimensions penalize.

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 very minimal description and parameter coverage, the overall picture is incomplete: the 'profile' parameter is unexplained, and there is no usage context or link to other tools. Though an output schema exists, the description fails to fill in basic operational context, leaving the agent guessing on how to invoke or select the tool.

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

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

The schema has no property descriptions (0% coverage) and the description only mentions 'a profile' without defining what format it expects (e.g., ID, handle) or how it affects results. This is insufficient for an agent to correctly construct the argument, especially when the parameter is optional but behaviorally meaningful.

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 identifies the resource as Pinterest boards and scopes them to a profile, which is clear and specific. It lacks an explicit verb, relying on the title to infer the 'list' action, but that is a minor omission. Among siblings like get_facebook_pages and get_linkedin_pages, the platform is highlighted, but the description doesn't explicitly distinguish it beyond the resource 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?

No guidance is given on when to use this tool versus alternatives or what conditions make it appropriate. The description merely states a fact about Pinterest boards without explaining selection criteria, prerequisites, or fallback behavior. The agent is left to infer from the name and sibling context.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds that it's a reference and includes human labels, but it doesn't disclose any additional behavioral traits such as output format, pagination, or rate limits. Since annotations cover the core safety, the added value is modest.

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 that starts with 'Reference:' to immediately signal its purpose. It includes examples and the key detail about human labels, with zero wasted words. The structure is optimal for an agent scanning tool definitions.

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 reference tool with an output schema present, the description adequately explains what the tool returns (metrics per platform with human labels). It doesn't describe the exact output structure, but the output schema likely covers that. No critical information is missing for an agent to decide to call it.

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

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

The tool has zero parameters, so the schema coverage is trivially 100% and there is nothing to explain. Per the calibration rule, a zero-parameter tool gets a baseline of 4, and the description correctly adds no unnecessary parameter 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 returns a reference of available metrics per platform, with examples and human labels. It distinguishes itself from analytics data tools by positioning it as a metadata/reference lookup rather than a data pull, so an agent can tell it apart from siblings like get_analytics or get_total_impressions.

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 when an agent needs to know which metrics are available, but it doesn't explicitly state when to use this tool versus alternatives like get_analytics or get_total_impressions. There is no mention of exclusions or when not to use it, leaving the decision partly to inference.

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

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

Annotations already cover the read-only and non-destructive nature. The description adds value beyond annotations by disclosing that post_metrics is not a fixed shape, may differ by platform, and enumerates the TikTok-specific extras. This is above-average behavioral context, though it doesn't cover platform absence behavior or response edge cases.

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 first sentence front-loads the main purpose, and the second sentence expands on the non-standard output shape. The TikTok field list is long but relevant to prevent an agent from expecting a fixed schema; still, it could be tightened without losing that insight.

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

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

Given the presence of an output schema and annotations, the description covers the key non-obvious point: results differ per platform. It also gives a concrete example of the extra fields. It doesn't explain which platforms are supported or how the request_id originates, but those are not critical for invoking the tool correctly.

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

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

With 0% schema coverage, the description helps by identifying the single parameter as the post identifier. However, it writes the parameter as `request_id` while the schema expects `requestId`, which is a small but real invocation risk. It doesn't explain where to obtain the request ID, so the semantic help is partial.

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 resource clearly: per-platform metrics for a specific post identified by a request ID. It distinguishes from general analytics by being post- and platform-specific, but it does not explicitly differentiate itself from close siblings like get_cached_post_analytics or get_platform_metrics.

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 implied usage is clear: call this when you need per-platform metrics for one post. However, there is no explicit when-not-to-use guidance or mention of alternatives, so the agent has to infer boundaries from the parameter 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 indicate readOnlyHint=true and destructiveHint=false, but the description adds substantial behavioral detail: pagination via `after`, a hard limit of 50 (with reasoning), platform-specific ID formats, the switch to replies with `commentId`, and the TikTok prerequisite (capability granted at connection, requiring reconnection). These disclose behavior not evident from annotations alone.

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

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

The description is moderately long but every sentence carries essential information: main purpose, platform handling, post identification, replies, and TikTok caveat. It is organized logically and avoids redundancy, though it could be slightly reorganized into clearer bullets for platform specifics. Overall, it is efficient 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?

Complete for a read-only, multi-platform comment-listing tool. The description covers platform quirks, capability prerequisites, pagination, replies, and limits. Combined with an output schema and annotations, an agent has everything needed to invoke it correctly across all supported networks.

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 every parameter is already documented. The description adds valuable enrichment: platform-specific meanings for `postId` (YouTube=videoId, LinkedIn=post URN, TikTok=video id with no URL lookup), the role of `commentId`, and the rationale for `limit`. This goes beyond the schema, though some details are already present in the property descriptions.

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

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

States the specific action ('List comments on a post'), the resource (comments), and clarifies it is a single endpoint for all networks via `platform`. It clearly distinguishes listing from comment manipulation tools (reply, create, delete) and from analytics tools by focusing on the read-only retrieval of 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?

Provides explicit guidance: to list comments use this tool; to get replies use the same tool with `commentId` (not another tool). It also covers platform-specific requirements (TikTok capability) and the fact that TikTok does not accept `postUrl`. Lacks an explicit 'when not to use this' compared to other read tools like `get_media` or `get_history`, but the comment-specific focus is clear.

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

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

Annotations already declare readOnly=true and destructive=false, so the safety profile is covered. The description adds meaning by enumerating returned queue details (slots, time windows, timezone) but does not go beyond that to mention auth needs, defaults, or behavior when profile_username is omitted.

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 front-loads the resource ('Posting queue configuration') and parenthetically lists key content fields. Every word adds value; there is no fluff.

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

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

With one optional parameter and no explanation of its meaning or effect, plus no mention of what happens when it is omitted, the description leaves an important usage gap. The output schema may cover return fields, but the input behavior is not sufficiently explained for confident 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?

Input schema coverage is 0% and the description does not explain the only parameter, profile_username. Although the name is somewhat self-explanatory, the description adds no information about whether it is required, what it filters, or how it affects the returned settings.

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 'Get queue settings' plus the description 'Posting queue configuration (slots per day, time windows, timezone)' clearly identify the resource and the data returned. It does not explicitly distinguish itself from sibling tools like update_queue_settings or preview_queue, but the getter verb and listed fields make the purpose 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?

No guidance is given about when to use this tool instead of alternatives such as update_queue_settings or preview_queue, nor are prerequisites or typical invocation contexts mentioned. The description implies it is a read operation, but it does not state exclusions or conditions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that posts come with platform-side metadata (subreddit, flair, score), which is useful, but it does not disclose pagination, ordering, or any limitations beyond that. 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 short but poorly structured. The first sentence about posting unavailability is a distraction that belongs in a separate operational note, not the tool description. The second part is a fragment lacking a clear verb, and the overall flow is disjointed.

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 tool with an output schema, the description still fails to clearly state its function. It leaves out an explicit statement of what it retrieves and does not explain the limit parameter. The unrelated warning further detracts from completeness. An agent could misinterpret the tool as related to publishing.

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

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

Schema coverage is only 50% (profile is documented in schema, limit is not). The description adds a hint that posts are 'published from a profile,' which maps to the profile parameter, but it provides no explanation of the limit parameter or its default behavior. It does not adequately compensate for the missing schema 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 implies the tool returns recent Reddit posts from a profile with metadata, but it lacks an explicit verb and is framed as a noun fragment. The opening sentence about Reddit posting being unavailable is unrelated to this read tool and confuses the purpose. It does not distinguish the tool from siblings like get_history or get_media.

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 only directive, 'Do not use reddit as a publish target,' pertains to publishing, not fetching posts, and is irrelevant to this read operation. No context for choosing this over other get tools is provided.

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 the specific polling behavior and the expected terminal states, which goes beyond the annotations. There is no contradiction; it simply adds useful behavioral context about how status evolves.

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-loads the purpose, and contains zero fluff. The polling condition is placed second, efficiently guiding usage. 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?

The tool has an output schema that presumably defines the `status` field, so the description does not need to repeat return structure. It gives the essential polling loop and terminal conditions. It does not mention error handling or what to do if the upload never reaches a terminal state, but for a single-parameter read-poll tool this 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?

Schema description coverage is 0% (the property has no description), so the tool description must compensate. It mentions `request_id` by name but adds little semantics: it only says 'by `request_id`', implying it is an identifier from an async upload but does not explain its format, origin, or how to obtain it. This is minimal value beyond the raw schema.

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

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

The description states a specific verb and resource: 'Check the status of an async upload' and identifies the required identifier `request_id`. It clearly distinguishes this from sibling tools like `get_job_status` or `get_media_upload` by focusing on async upload status, though it doesn't name alternatives. The purpose is unambiguous.

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

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

The description provides clear usage guidance: 'Poll this until `status` is "success" or "failed".' This tells the agent exactly when to call it and how to interpret the result iteratively. It does not explicitly mention when to avoid it or alternative tools, but the polling instruction is strong contextual 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, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: that the output shape depends on `type`, that capability requirements differ by type, and that the platform parameter selects the network. It also implicitly acknowledges the platform_not_supported error via the schema, but that is part of the parameter description.

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 concise and front-loaded with the core purpose. It contains some redundancy ('One endpoint for both questions' is restated later), but overall it is well-structured and each sentence adds value. Not overly 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 complexity (6 params, 2 enums, 3 required) and the existence of an output schema, the description covers the essential behaviors: what it returns for each type, capability prerequisites, and how platform selects the network. It does not mention pagination or limits, but the output schema likely covers those. Overall, it is sufficiently complete for an agent to use correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does add a few nuances (e.g., q should not include '#', and the capability requirement per type), but these are minor and the schema already explains all parameters effectively. It does not fully compensate for any gaps because 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 clearly states it provides hashtag or keyword suggestions, explicitly distinguishes between the two output modes, and clarifies that it works across networks via the platform parameter. It avoids vagueness and is easily distinguishable from sibling tools like get_post_analytics.

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 explains when to use each type ('pick tags that actually have reach for a caption' for hashtags, 'useful for the next video topic' for keywords) and notes capability requirements (profile_analytics and trend_search), with a pointer to list_users. It does not explicitly name alternatives or state when not to use the tool, but the use cases are clear.

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

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

Annotations already declare this a read-only, non-destructive operation. The description adds value by revealing that impressions are aggregated from daily snapshots rather than live data, but it does not disclose limitations like timezone handling, snapshot delay, or how multiple date fields (`date` vs `startDate`/`endDate`) interact.

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

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

The description is two short sentences with no filler. The core result is front-loaded, and the second sentence gives the most important parameter semantics without repetition or verbosity.

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

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

With 8 parameters, 0% schema description coverage, and a non-obvious set of optional interactions (`date` vs `period` vs `startDate`/`endDate`, plus `metrics`, `breakdown`, `platforms`), the description is too minimal for an agent to reliably choose and fill optional parameters. The output schema covers return values, but input semantics remain under-specified.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It explains only `period` and `startDate`/`endDate`, leaving the other five parameters (`date`, `metrics`, `breakdown`, `platforms`, `profileUsername`) effectively undocumented in both schema and description. This is a significant gap for an 8-parameter tool.

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

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

The description uses a specific verb-resource pairing ('Sum of impressions for a profile') and notes the data source ('daily snapshots'). It is clear, but it does not explicitly differentiate this tool from closely related siblings like get_platform_metrics or get_analytics, so it falls short of a 5.

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

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

The description gives concrete parameter guidance: use `period` for presets, or `startDate`/`endDate` for custom ranges. However, it does not say when to use this tool instead of the many sibling analytics tools, and it gives no exclusions or prerequisites.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only safety is covered. The description adds only a vague 'recent' ordering hint and profile/platform scoping, without clarifying pagination, auth requirements, or filtering 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 one short sentence with no fluff and important scoping words appear early. It could be rewritten as a complete imperative sentence, but it is efficient.

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

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

For a tool with no parameter descriptions and no enums, the absence of platform values and user identifier semantics leaves an agent guessing about valid inputs. The output schema covers return shape, but calling the tool correctly is under-specified.

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

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

Schema description coverage is 0%, so the description must compensate. It maps 'profile' to user and 'platform' to platform, but it does not explain accepted platform values, user identifier format, or limit behavior. This is minimal semantic help.

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 identifies the resource (DM conversations), the scope (a profile on a platform), and the recency filter. The verb is only present in the title/name ('List'), not the description, so it stops just short of a fully self-contained 5.

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

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

No guidance is given for when to use this tool versus alternatives such as send_dm or the many get_* tools. The name implies a read operation, but no conditions or exclusions are stated.

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

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

The read-only and non-destructive nature is already covered by annotations. The description adds the useful clarification that 'scheduled' means 'not-yet-published', but does not disclose any additional behavior such as ordering, pagination, or default limits.

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

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

One short, front-loaded sentence states the action, object, and a clarifying definition. There is no redundant or filler content.

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

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

For a parameterless read-only operation, the description captures the essential scope and meaning. It would be slightly stronger if it mentioned the output shape, but the simplicity of the tool makes the absence non-critical.

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 sensitive to the empty input schema, so the description does not need to explain parameters. Its clarity about the resource being listed is sufficient for an agent to know what the call will return.

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 ('List') with a clear resource ('post') and scope ('all currently scheduled'). The parenthetical '(not-yet-published)' removes ambiguity about what 'scheduled' means and distinguishes this from post status or history tools.

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

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

The description makes the intended use implicit: call this when you need the set of posts scheduled but not yet published. However, it does not explicitly say when to prefer this over related tools like get_status or get_history, or mention any exclusion conditions.

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 openWorldHint=false, and the description reinforces a read-only list operation. It adds concrete detail about the response (connected social accounts, and a `capabilities` array with TikTok fields), which helps an agent predict output without over-explaining.

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 core operation. The second sentence bundles a useful but somewhat long list of TikTok capability fields; still no filler.

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

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

For a zero-parameter read-only list call, the description plus annotations cover the essentials: what is returned, and the safety profile. It doesn't mention pagination or the exact shape of the response object, but 'all' and the field list largely compensate.

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 no parametersasi input schema fully covers this. The description adds no parameter syntax or constraints, 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 names a specific verb ('List'), the resource ('Upload-Post profiles'), and the scope ('all in the account'), with a concrete note that connected social accounts are included. An agent can tell this from the many sibling tools without opening any schemas.

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

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

The use case is implied – list all profiles in the account – but there is no explicit guidance about when to prefer this over siblings like get_account_info or get_media, nor any prerequisites or exclusion criteria. It is serviceable but not actively instructive.

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

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

Annotations indicate destructiveHint=true slash readOnlyHint=false, which suggests state-changing behavior, but the description does not contradict that. It adds value by specifying that some actions (delete) are destructive and others (pause, resume) are state changesholistic. It does not detail the response format, but output schema exists, and the annotations already signal non-read-only nature. However, it could have warned that 'delete' is irreversible, so it's not a full 5.

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

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

The description is compact and front-loaded with the main purpose. The action-to-parameter mapping is useful and in one sentence. It could be slightly more structured (e.g., bullet points) for scanning, but it is 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?

Given the tool's complexity (9 params, multiple actions, output schema exists), the description covers the critical action-parameter relationships. However, it omits information about the operation's side effects (e.g., whether starting a monitor immediately begins polling, or how logs are returned). It is adequate for basic usage but leaves gaps for an agent to infer.

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

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

Schema description coverage is high (89%), meaning most parameters already have descriptions. The tool description adds a small amount of value by mapping actions to required parametersholistically, but it largely restates what the schema already says. No new parameter semantics or examples are given, so this is a 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 clearly identifies the tool as controlling Instagram AutoDM monitors and enumerates the possible actions. It differentiates from sibling tools by focusing on DM automation rather than post management or user management. However, it does not explicitly name a sibling to distinguish from, so it loses a point.

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 action-specific parameter requirements: for 'start' you need post_url, reply_message, profile_username; for stop/pause/resume/delete/logs you need monitor_id; for status you may set include_inactive. This is explicit and practical, guiding the agent directly on which parameters to supply for each action.

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 reinforces the read-only, non-destructive nature implied by annotations by framing the result as a preview of 'what would land'. It also discloses the optional nextSlot output mode, adding useful behavior 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?

Two sentences with no filler. The core purpose is front-loaded, and the optional nextSlot behavior is stated succinctly in the second sentence.

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

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

The output schema and annotations cover return shape and safety, and the core preview behavior is stated. However, the unexplained profile_username parameter and lack of routing guidance against sibling read tools leave meaningful gaps, making this only minimally complete.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It explains nextSlot=true precisely but says nothing about profile_username, leaving a likely filter parameter completely unexplained and forcing the agent to guess its 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?

States a specific action, 'Preview', against a clear resource, 'upcoming queue slots', and explains what it shows: 'what would land in them'. This is distinct from sibling read tools like list_scheduled or get_status without requiring schema inspection.

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

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

The description gives clear context on when to use the tool: when you want to see upcoming queue slots and their hypothetical contents, optionally narrowed via nextSlot=true. It does not explicitly name alternatives or exclusion conditions, but the usage context is specific enough to guide 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 says 'Post a public reply', which is a state-changing write operation, but the annotations declare readOnlyHint=true and destructiveHint=false. This is a direct contradiction: an agent could infer the tool is read-only while it actually publishes content.

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

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

The description is one compact, front-loaded sentence with no filler.

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

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

It omits the operation's write effects, required permissions, expected response, and how it differs from the sibling reply_to_comment. The contradiction with the read-only annotation leaves an agent with dangerously incomplete 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?

Schema coverage is low and the description adds little parameter meaning. It clarifies 'comment' context, but does not explain the critical 'user' parameter, what form the message takes, or the relationship between user and commentId.

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

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

The description clearly states a specific action (post), a specific object (public reply), and placement (under the original Instagram comment). It is not explicitly contrasted with the sibling reply_to_comment, so it loses the top point.

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

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

There is no guidance on when to choose this tool over siblings like reply_to_comment, nor any prerequisites such as authentication, comment ownership, or rate-limit considerations.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the destructive, side-effecting nature is known. The description adds the 7-day reply window constraint, which is useful behavioral context, but it doesn't describe other consequences like irreversibility or on-behalf-of behavior. With annotations carrying the safety signal, this is adequate.

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

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

One concise sentence front-loads the core action and the time constraint. No redundant words 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?

Despite having an output schema, the tool's call structure remains unclear because required parameter semantics are undocumented. Critically missing: the role of the 'user' parameter (e.g., Instagram username? comment author handle?), how 'commentId' relates to comments, and how to discover valid 'commentId' values via sibling tools like get_post_comments. A minimal description does not fully equip an agent for correct invocation.

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

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

Schema description coverage is only 40%; 'buttons' and 'platform' are documented, but required params 'user', 'commentId', and 'message' have no descriptions. The description does not explain what 'user' means in this context, how to obtain 'commentId', or what content 'message' should contain, so agents are left to guess on critical inputs.

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

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

The description states a specific verb and resource: 'Send a private DM to the author of an Instagram comment.' The '7-day reply window' narrows context, and the title plus sibling names (public_reply_to_comment, send_dm) make the tool's unique purpose immediately distinguishable.

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 by specifying the 7-day reply window and implies the intended use is private replies rather than public ones. However, it does not explicitly mention alternative tools such as public_reply_to_comment or send_dm, nor does it say 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?

Annotations already declare `destructiveHint` true and `readOnlyHint` false, signaling mutation. The description adds the create/update nature, which is consistent. It does not disclose extra behavioral details such as whether an existing reply is overwritten, permission requirements, or rate limits, but with annotations covering the safety profile, the description provides minimal added 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, front-loaded sentence that states the action first, then gives the target specification. There is no filler or redundancy; every phrase contributes to 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?

Given the tool has an output schema and the schema documents all parameters with full coverage, the description covers the key usage nuance (review_name vs review_id+location_id). It lacks explicit prerequisites like required permissions or overwrite behavior, but the output schema likely captures the response. The description is adequate for a mutating tool with 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?

Schema coverage is 100%, so each parameter is described in the schema. The description adds value by grouping `review_name` as a standalone option and `review_id` + `location_id` as an alternative, clarifying the mutual relationship and how to construct the resource path. This goes beyond the schema's individual field descriptions.

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

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

The description states the specific action ('Create or update the owner reply') and targets a specific resource ('a Google Business review'). It clearly distinguishes from sibling tools by naming the platform and the owner-reply nature, making its purpose unmistakable.

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

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

The description explains how to specify the target via either `review_name` or `review_id` + `location_id`, which is useful. However, it does not explicitly state when to use this tool versus alternatives like `reply_to_comment` or `public_reply_to_comment`, leaving the condition to the agent's inference. The usage guidance is implied but not explicitly contrasted with siblings.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the description need not repeat that. However, it adds no additional behavioral context: it does not explain what happens on retry (e.g., whether a new job is created, if the original is replaced), whether authentication is required, or any side effects. The openWorldHint=true annotation suggests external effects, but the description is silent on that. For a mutation tool, this is a significant gap.

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

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

Two sentences, both purposeful. The purpose is front-loaded and the identifier guidance is immediately actionable. No wasted words or redundancy with the schema.

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?

An output schema is present, so return values are covered. The description covers the core purpose and parameter selection, but it omits the requirement that one of the two identifiers must be provided (both are optional in the schema). It also doesn't state what constitutes a 'failed upload' or any error conditions. For a tool with two optional parameters and no required fields, this ambiguity is a notable 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 description coverage is 100% for both parameters. The description adds meaning by mapping requestId to async uploads and jobId to scheduled/queued uploads, which is not in the schema descriptions. This helps the agent select the correct parameter. It could further clarify that exactly one is required, but the mapping itself is valuable.

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: retrying a failed upload. It specifies the two identifier types (requestId for async, jobId for scheduled/queued) and the resource (failed upload). It does not explicitly name sibling tools or differentiate itself, but the purpose 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 guidance on which identifier to use based on upload type (requestId for async, jobId for scheduled/queued). However, it does not specify when to use this tool versus alternatives (e.g., cancel_scheduled, get_job_status, or upload tools), nor does it mention prerequisites like the upload being in a failed state. The guidance is clear on how to select parameters but not on broader usage context.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the agent knows this is a mutating, potentially destructive action. The description adds the prerequisite of a connected Upload-Post profile and the source of recipient_id, but does not disclose other behavioral traits such as delivery semantics, rate limits, or irreversibility. Given the annotations cover the safety profile, the description adds some value but remains limited.

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, perfectly front-loaded with the primary action and resource, followed by the key prerequisite. There is no fluff or repetition of schema details. Every word adds value.

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

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

For a simple send operation with a full input schema and an existing output schema, the description covers the essential context: what it does, the required connection, and how to get the recipient. It does not elaborate on edge cases or error conditions, but for this tool's simplicity and the presence of annotations covering safety, it is complete enough.

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 each parameter is already documented. The description adds meaningful guidance on how to obtain recipient_id (from comments or DM tools) and implies that user should be a connected profile, but this is marginal over the schema. For a well-covered schema, baseline is 3, and the extra note is helpful but not comprehensive enough to raise the score.

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 ('Send an Instagram DM'), the resource (recipient), and the context ('from a connected Upload-Post profile'). It also specifies how to obtain the critical recipient_id, making the tool's purpose immediate and unambiguous. There is no sibling that sends DMs, so it is easily distinguished.

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 guidance on the prerequisite for the recipient_id ('returned by Instagram comments or DM conversation tools'), which is necessary for correct usage. However, it does not explicitly say when to use this tool instead of alternatives like reply_to_comment or manage_autodms, nor does it mention any exclusions or conditions. The usage context is implied but not fully explicit.

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

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

Annotations already indicate a non-read-only, non-destructive operation. The description adds that the job is private, goes through Upload-Post, and returns a pollable `job_id`, but it does not disclose quota/consumption, authentication, or failure behavior. No contradiction with annotations exists.

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

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

Three sentences with no filler, front-loading the purpose before parameter guidance and return behavior. Every sentence contributes to the agent's ability to select and invoke the tool.

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

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

Covers the main choices (`input_url` vs `files`), optional command behavior, and the expected `job_id` polling flow, with full schema and output schema support. It could be stronger on the implicit requirement to supply either `input_url` or `files` and on consumption/quota context, but those are minor 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. The description adds useful mapping: `input_url` for a single source, `files` for multiple sources, and `full_command` for explicit editing operations, though it omits `output_filename` and partly repeats schema wording.

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

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

States a specific verb ('Submit'), a specific resource ('FFmpeg processing job'), and the mechanism ('through Upload-Post'). It clearly distinguishes itself from sibling polling, download, and consumption tools like get_ffmpeg_job and download_ffmpeg_result.

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 `input_url` vs `files` and notes that `full_command` is optional for explicit trim/transcode/watermark/thumbnail operations. It references `get_ffmpeg_job` for polling, though it does not explicitly enumerate alternatives 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 signal readOnlyHint=true and destructiveHint=false. The description adds non-obvious behavioral context: TikTok requires both parts, so the returned `location_id` and `location_name` must be passed as `tiktokLocationId` and `tiktokLocationName` in upload_video's platformOptions. It also discloses the capability precondition. 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 tightly written sentences: front-loaded purpose, a precise instruction for using the result, and a capability note. Every sentence carries distinct, necessary information with no filler or redundancy.

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

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

The description covers the tool's purpose, how to consume its output (via upload_video), and the availability precondition. With an output schema present and annotations covering read-only/non-destructive behavior, an agent has enough information to invoke the tool correctly. Minor omissions like result-set size or error cases are covered by structured data or are non-critical.

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 fully documents both parameters: `query` includes example and max length, `profile` explains it must be an Upload-Post profile name with a TikTok account connected. The description adds no additional parameter-level detail beyond referencing how the result is consumed, so it meets the baseline for 100% 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 states a specific verb and resource: 'Search TikTok places to tag on a post.' It clearly differentiates the tool from sibling TikTok search tools like tiktok_music_search by focusing on location/place tagging, and the purpose is unambiguous.

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

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

The description gives clear context for when to use the tool: when you need a TikTok place to tag on a post, and it explicitly conditions usage on TikTok connections that declare the `location` capability, pointing to list_users for verification. It does not explicitly contrast with alternatives, but the specialized purpose makes the condition evident.

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