uplika

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

Annotations already signal this is a mutating, destructive-hint operation. The description adds valuable behavioral context by stating that approving makes the reply public and that the tool can also ignore a held reply. This goes beyond the annotations without contradicting them.

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

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

The description is two sentences with no wasted words. It front-loads the platform and core action, then gives the key consequence and queue-reading hint.

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

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

For a mutating tool with four parameters and no output schema, the description covers the essential behavior, consequences, and how to locate the queue. It could be more explicit about the effect of ignore and the return value, but the main operational context is present.

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

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

Schema coverage is 75%, so most parameters are already documented. The description adds a small amount of extra meaning by linking the approval/ignore action to the approve boolean and hinting at queue listing with 'pending: true', but it does not significantly clarify accountId or the exact mechanics of the pending filter.

Input schemas describe structure but not intent. Descriptions should explain 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 ('approve') with a clear resource ('a reply held by reply approval on one of the account's posts') and scopes it to Threads. It clearly distinguishes the action from the many reply-related siblings like delete_reply or hide_reply by focusing on the approval workflow.

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

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

The description gives clear context: this is Threads-only, applies to held replies, and tells the agent how to read the pending queue ('pending: true'). It does not explicitly name alternative tools or state when not to use it, but the context is enough for basic routing.

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

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

Annotations only provide readOnlyHint=true. The description goes far beyond by explaining the extension's role, the offline behavior with wake commands, the state values, userMessage for relaying, queued count, extensionVersion/kinds, and the behavior that queued posts go out within a minute of Chrome opening. 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 dense paragraph but every sentence carries useful information about scope, workflow, response fields, and relationships to sibling tools. It is not excessively verbose for the complexity it covers, though it could be better structured with bullets.

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

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

The description fully explains the response fields (state, userMessage, queued, extensionVersion, kinds, wake commands) and the operational sequence. Even without an output schema, an agent would know exactly what to expect and how to use the tool.

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

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

Schema coverage is 100% and both parameters are already well-described in the schema. The description does not add parameter-specific semantics, but since the schema covers them, 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 clearly states the tool checks the Naver Blog extension status and provides wake commands when offline. It explicitly scopes to Naver Blog and distinguishes itself from siblings like publish and get_post by explaining when it should be called.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 instructs to call before publishing to Naver Blog, and provides a conditional workflow for when online=false, including running OS-specific wake commands and recalling the tool. It also notes that publish returns the same bridge object when offline, and mentions delete_post/update_post for queued posts, giving clear guidance vs 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 convey readOnlyHint=false and destructiveHint=false, so the description only needs to add meaningful behavior. It adds that the result is a draft rather than an active automation, which is material for an agent deciding what happens after the call. It does not mention side effects or return values, but the draft behavior is genuine 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?

Three short sentences with no filler. The primary action is front-loaded, the draft outcome is stated immediately, and the fallback to put_automation is included in one compact 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 description together with the schema covers where templateId and params come from, the draft behavior, and the alternative path when no template fits. Since there is no output schema, an explicit note about what the call returns would improve completeness, but this is a minor gap for a create tool.

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

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

Schema coverage is 83%, and the schema already explains templateId, params, accountId, enabled, and workspaceId. The description reinforces that params come from the chosen template, but adds no new parameter-specific meaning beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description names a specific verb ('Create'), resource ('automation'), source ('any template in list_automation_templates'), and result ('Creates a draft'). It also signals the difference from put_automation, so an agent can distinguish the two tools without opening their schemas.

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

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

It explicitly says to use this tool when a template covers the flow and to use put_automation instead when building the document by hand. This is a clear when-to-use condition with a named alternative.

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

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

Annotations only carry readOnlyHint=false and destructiveHint=false, so the description bears the full transparency burden and delivers richly: Meta's private-reply/7-day/24-hour-window mechanics, the Instagram-vs-Facebook requireFollow asymmetry, the media_presign→mediaId pipeline, the post value forms, and the complete execution order (opening DM → askEmail → requireFollow → deliver → followUp). No contradiction with annotations.

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

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

Long but every sentence earns its place given the tool's complexity. The most decision-relevant fact (draft, nothing goes out) is front-loaded; platform differences, ordering, and edge cases follow in a logical flow. No filler or repetition of schema content.

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

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

For a 20-parameter tool with nested objects, platform differences, and no output schema, the description covers the essential behavioral mechanics almost exhaustively. The one gap: it never states what the call returns (e.g., the draft automation id needed by enable_automation), which matters more because no output schema exists to fill that void.

Complex tools with many parameters or behaviors need more documentation. 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 70%, so the baseline is 3; the description pushes higher by adding meaning the schema lacks: what 'post' values mean in practice ('next' for the next post you publish), how files reach deliver.mediaId via media_presign, and the consequences of openingDm:false (window never opens, so requireFollow/askEmail/followUp/files are rejected). A few obscure params (emailRetry, recheckTitle, notFollowingMessage) remain undocumented in both, capping 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?

Opens with a crisp definition: 'when someone comments on a post, DM them.' The verb (create), resource (comment-to-DM automation), and the draft status ('nothing goes out until enable_automation') are all explicit, and the description clearly differentiates from siblings like send_dm, reply, and create_automation.

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

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

Gives explicit when-to-use and when-not-to-use guidance: 'Threads has no DMs at all; use create_automation with comment_public_reply' names the exact alternative. It also routes to enable_automation as the follow-up step and warns about the 409 next_post_taken conflict. The schema's 'enabled' field reinforces this with 'Prefer leaving it off and calling enable_automation after the person confirms.'

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

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

Annotations already indicate destructiveHint=true, so the agent knows it's destructive. The description goes far beyond that by detailing irreversibility, per-channel daily limits, time windows (Telegram 48h), platform restrictions (Instagram, Facebook, TikTok), and behavior on scheduled/draft posts. This is substantial behavioral disclosure that annotations alone 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?

The description is long but every sentence carries necessary platform-specific information. It is front-loaded with the core purpose and irreversibility, then systematically covers each platform's constraints. While verbose, the structure is logical and each detail is essential for correct usage, so it earns its place.

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

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

The description comprehensively covers operational constraints across all supported platforms, including limits, restrictions, and edge cases like scheduled/draft posts. It does not describe the return value or error handling, but given the absence of an output schema and the focus on behavior, the omission is minor. The tool's complexity is well addressed.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters. The description adds minimal additional semantics: it mentions that links work for posts written in the channel's app, but that is already stated in the schema's id description. Thus, the description adds no meaningful value beyond the schema, warranting the baseline 3.

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

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

The description clearly states the tool deletes a post from the channel permanently, distinguishing it from update_post (edit), hide_reply (hide), and publish (create). The verb 'delete' and resource 'post' are specific, and the scope 'from the channel' sets expectations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 strong contextual guidance: it explains when deletion works (e.g., on scheduled/draft posts it cancels them) and when it doesn't (e.g., Instagram accounts not linked via Facebook). It also advises confirming with the person first, which is a usage guideline. It doesn't explicitly name alternative tools, but the platform-specific constraints effectively guide when not to use it.

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

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

Annotations declare destructiveHint=true, but the description goes further: it discloses irreversibility, channel-specific reach differences, and who it removes (anyone's comment vs only the connected account's reply. This is valuable context not present in 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?

Every sentence earns its place: the core action, the alternative, channel differences, and the recommendation. The key point is front-loaded and the length is proportionate to the complexity.

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

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

For a destructive tool with channel-dependent behavior, the description covers irreversibility, channel support routing, and the alternative. Combined with full schema coverage and annotations indicating destructiveness, nothing an agent needs to decide whether to call it 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%, with clear descriptions for postId, replyId, and workspaceId. The tool description adds no parameter-specific meaning beyond what the schema already provides, so the baseline of 3 is correct.

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

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

The description opens with a specific verb and resource ('Delete a comment for good') and immediately contrasts itself with the sibling hide_reply, so an agent can distinguish it 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 states when not to use this tool ('This is not hide_reply: it cannot be undone') and names the alternative ('Prefer hide_reply when the person just wants it out of sight'). It also references list_platforms for determining channel support.

Agents often have multiple tools that could apply. Explicit usage 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 readOnlyHint annotation, the description reveals important behavior: not_supported is expected for non-Naver platforms, results mirror the same grammar used by the publisher, and topic-specific sections include silent-failure mistakes. This gives the agent realistic expectations about outputs and errors.

Agents need to know what a tool does to the 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 earns its place: purpose, exclusion, when to call, topic behavior, and source authority. It is front-loaded with the key purpose and scoping, and the later examples are illustrative, not 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 read-only lookup tool with three parameters and no output schema, the description is complete. It covers supported platform, query behavior, default behavior, result provenance, and a non-error condition. An agent has enough to decide when to call it and what to expect.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning beyond the schema: it explains what happens without a topic vs. with one, and that returned values come from the grammar the publisher validates against. This complements rather than repeats the schema's parameter 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 clearly states the tool's purpose: describe the body markup grammar for a channel, specifically Naver Blog. It distinguishes scope by noting every other platform returns not_supported, and ties the tool to the publish workflow rather than other sibling operations.

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

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

Usage guidance is explicit: call this before writing a Naver Blog body for the first time, or when basic formatting doesn't cover a need. It also tells the agent not to treat not_supported as an error and clarifies that other platforms don't support this lookup.

Agents often have multiple tools that could apply. Explicit usage 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 safety profile is partially covered. The description adds a meaningful behavioral detail: existing waiting runs are preserved, only new starts are blocked. This goes beyond the annotations and clarifies the non-destructive nature, which is valuable for an agent deciding whether to call it.

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

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

The description is two sentences with zero filler. The core action is front-loaded, and the key behavioral distinction is stated immediately. Every sentence carries information that aids tool selection and correct invocation. This is an ideal size for a simple action tool.

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

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

For a tool with one required parameter and no output schema, the description covers the main effect but leaves ambiguities: it does not specify what happens to currently executing runs (only 'waiting' ones), whether the stop is reversible, or how to restart. These gaps are minor for a simple stop action but could affect an agent's decision in some scenarios.

Complex tools with many parameters or behaviors need more documentation. 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 50% description coverage – workspaceId is explained, but id is not described. The tool description mentions neither parameter, providing no additional meaning for id, which is required. Given the low schema coverage, the description should compensate, but it fails to do so. The agent must infer id semantics from the context alone.

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

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

The description states a specific verb and resource: 'Stop an automation.' It clearly indicates the tool halts automation, and the added detail about runs waiting for a button distinguishes it from purely starting or creating automations. It doesn't explicitly name alternative tools, so it loses a point for no sibling differentiation.

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

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

The behavioral note 'Runs already waiting for a button stay waiting but nothing new starts' implies the intended use case (stop new starts while letting pending manual steps continue). However, it does not explicitly state when to use this over alternatives like disable or delete, nor does it mention any prerequisites or exclusions. The guidance is implied rather than stated.

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

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

Annotations already flag destructiveHint=true, and the description adds valuable detail: messages begin going to real people, confirmation is required, enabling is refused under certain conditions, and webhook subscription is warned about. This goes well beyond the structured annotations.

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

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

Every sentence earns its place. The most important warning is front-loaded, and the failure modes are packed into three tight sentences 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?

The definition covers the key behavioral constraints, safety implications, and refusal modes an agent needs to act responsibly. It is slightly incomplete because it never specifies what the required 'id' parameter represents, but the overall picture is solid for a simple two-parameter mutation.

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

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

Schema description coverage is only 50%, with the required 'id' parameter completely undocumented in both the schema and the description. The description adds no parameter meaning; the agent must infer that 'id' refers to an automation ID.

Input schemas describe structure but not intent. Descriptions should explain 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, 'Turn an automation live,' and clarifies its real-world effect: 'This is the moment messages start going to real people.' This clearly distinguishes it from siblings like create_automation and disable_automation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 contextual guidance: confirm with the person first, and explains the one-automation-per-account constraint and the error cases next_post_taken, reconsent_required, and webhook warnings. It does not explicitly name alternatives or say when not to use, but the context is strong.

Agents often have multiple tools that could apply. Explicit usage 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 readOnlyHint=false and destructiveHint=true, correctly implying a mutating action. Description adds behavioral details critical for agent expectations: mutual requests become pending, 'already a neighbor' returns as 'already', and there is no unfollow. It also notes that the 'message' parameter is ignored unless mutual is true. Adding specific return semantics (already) is valuable beyond the generic annotations. Slight deduction for not explicitly stating that choosing follower status is permanent (given no unfollow), but that's implied.

Agents need to know what a tool does to the 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, opening with the core action and then immediately highlighting a platform-specific constraint ('Naver Blog only'). It then explains the two modes and a special return value, with a final note about 'no unfollow'. While it is a paragraph, each sentence contributes a distinct piece of actionable info. The ordering is sensible: action, key distinction, behavioral result, and boundary. A slight deduction for length but overall well-structured and front-loaded.

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

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

Given the tool has 5 parameters, one required, and no output schema, the description covers the key use cases: how to follow normally, how to follow mutually, outcomes for both, and the absence of unfollow. It addresses the optional parameters indirectly by saying they are only needed in multi-account scenarios, which is sufficient context. It lacks explicit mention of error cases beyond 'already', but with no output schema, listing all possible return values isn't strictly necessary. The description is sufficient for a competent agent to pick the right options and understand the flow.

Complex tools with many parameters or behaviors need more documentation. 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 description doesn't need to repeat parameter descriptions. However, the description adds value by explaining the behavioral interplay: the 'message' is sent only with a mutual request, and that mutual requests require acceptance (resulting in pending status). It also clarifies that 'accountId' and 'workspaceId' are optional unless there are multiple, providing selection criteria. This adds context that the schema descriptions (which likely say 'which' but not when) do not fully capture.

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

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

Description clearly states the action ('Follow an account'), the specific resource (Naver blog as a neighbor), and provides a crucial scoping constraint ('Naver Blog only today' removes ambiguity about platform). Distinguishes from siblings like 'like' or 'reply' by focusing on neighbor-following. It also differentiates the two behavioral modes (mutual vs plain) with explicit timing (immediate vs pending acceptance).

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

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

Description includes explicit when-to-use guidance: 'mutual: true' is used when a mutual request is needed; 'without it' plain neighbor. It also states the consequence of the 'mutual' option (pending until accepted). It disambiguates from other actions by specifying 'no unfollow', clarifying that this is one-way. While it doesn't name alternatives, the description makes the use case and decision rules explicit.

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

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

The readOnlyHint annotation already establishes safety, and the description adds useful behavioral context: the returned fields, that version is required for put_automation, and that templateParams only appear when the flow still has its template shape. This goes beyond the structured annotations.

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

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

Two sentences, no filler, and each sentence earns its place: the first defines the core output, the second adds the version and templateParams details that matter for downstream use. Information is front-loaded 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 simple read operation with a fully documented schema and readOnlyHint, the description adequately covers the return payload and even notes a conditional field. It could mention error cases or more about the 'document' structure, 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 100%, so the baseline is 3. The description does not add parameter-level detail, but the schema already explains id and workspaceId well, including when workspaceId is needed and how to handle ambiguous cases.

Input schemas describe structure but not intent. Descriptions should explain 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 a single-resource read: 'One automation as a document' with specific fields (triggers, nodes, start). It distinguishes itself from list-oriented siblings by emphasizing 'One automation' and connects to put_automation through the version field.

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

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

The description provides clear context: use this to get a single automation and its version, which is explicitly stated as needed by put_automation. It does not explicitly name alternatives or exclusion criteria, but the single-vs-list contrast and the version-for-update link give usable guidance.

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

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

Annotations already declare readOnlyHint=true, so the description doesn't need to restate safety. It adds valuable behavioral context: the Instagram-only limitation for follow relationships, the condition 'only for people who have messaged', and the absence of follower lists on any channel. It also implies the refresh parameter behavior by mentioning re-reading from the channel in the schema, but the description itself doesn't discuss rate limits or error behavior. Still, it adds meaningful context beyond annotations.

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

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

The description is two sentences, front-loaded with the most important information (what a contact is and what fields are returned), followed by a crucial limitation. Every sentence earns its place; there is no fluff or repetition of schema details. The structure is ideal for an agent scanning quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 tool with a simple schema (one required id, two optional params), the description covers the return fields and key limitations. It doesn't describe the output format (no output schema exists), but the field list effectively substitutes for that. It also doesn't mention pagination or error cases, but for a single-contact read that's less critical. The main gap is not explicitly stating when to use this vs. list_conversations or list_accounts, but the description's clarity about what it returns makes it complete enough for most agents.

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

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

Schema description coverage is 67% (refresh and workspaceId have descriptions; id has none). The description doesn't explicitly explain the id parameter, but it's obvious from context that id identifies the contact. The description adds meaning by clarifying what data is returned for a given contact, which helps an agent understand what the id refers to. The refresh and workspaceId parameters are already well-described in the schema, so the description doesn't need to repeat them. This is slightly above baseline because the description clarifies the overall purpose of the parameters.

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

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

The description clearly states the tool reads a single contact and enumerates the exact fields returned (name, username, follow relationships, follower count, tags, opt-out, messaging window close). It also distinguishes itself from sibling tools by noting follower lists don't exist on any channel, making this the closest thing. The verb 'read' matches the title and readOnlyHint.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 on when to use this tool: when you need contact details, especially follow relationships and messaging window info. It explicitly notes the Instagram-only limitation and that follower lists don't exist, which helps an agent avoid expecting a list tool. However, it doesn't explicitly name alternative sibling tools like list_conversations or list_accounts for when a list is needed, 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 declare readOnlyHint=true, so the agent knows this is safe to call. The description adds a useful behavioral nuance: views and shares may be null when the platform has not reported them yet, and null is distinct from zero. It does not disclose pagination, rate limits, or data freshness/recency, but for a read-only metrics retrieval with a single publish id, the additional null guidance is meaningful. This sits at a solid 3, not higher because the main safety profile is already carried by annotations and no further behavioral traits are disclosed.

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

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

The description is a single, compact sentence that states the resource and the key metric fields, plus a crucial caveat about null values. It is front-loaded: the first clause says exactly what the tool returns, and the second clause handles the only real edge case an agent needs to know before calling. A few extra words could mention the response format, but for a read-only single-item tool, the size is appropriate.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 tool with one required parameter, a fully covered schema, and an annotations block declaring it safe, the description covers the core behavior and the most important data nuance (null vs zero). No output schema exists, so the metric list is essential context and is provided. It doesn't describe the exact JSON shape, but the listed metric names give an agent enough to interpret the result, and the read-only hint plus id resolution rules in the schema complete the picture.

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

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

Schema description coverage is 100%, so the baseline is 3; the description adds value by noting that views and shares can be null, which relates to the returned data rather than the parameters themselves. The description does not add parameter-level semantics beyond the schema, but it also does not need to, since the id and workspaceId are fully described in the schema. The null comment is a behavior note rather than a parameter note, so the score stays at baseline.

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

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

Clear verb+resource: it fetches metrics for one publish. The description explicitly lists which metric fields are included — views, likes, replies, reposts, quotes and shares — and notes null handling, which distinguishes it from a generic 'get metrics' definition and provides concrete expectations. The title 'Get post metrics' reinforces the same behavior without adding ambiguity.

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

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

The description implies this tool is for a single publish object and is separate from list_posts/list_channel_posts/list_replies, which are list-oriented siblings. It doesn't explicitly say 'use this instead of X when you need metrics for one publish', but the resource scope is clear enough for an agent to infer the correct context. It could improve with an explicit when-not-to-use or alternative mention, but the semantics are sufficiently 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?

With readOnlyHint already declaring the operation safe, the description adds useful behavioral context: it returns per-target status and explains that failed targets include a reason. This helps an agent know what to expect without opening the output. It does not detail error handling or edge cases, but the annotation covers the main safety aspect.

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

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

The description is only two sentences and contains zero filler. The key point (what the tool returns) is front-loaded, and the alternative guidance is given in a concise second sentence. Every word contributes to the agent's 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 there is no output schema, the description's summary of return content (per-target status and failure reasons) is essential and present. It also addresses the common ambiguity of post links by pointing to open_post. It could mention how errors are surfaced, but overall it is sufficient for a tool with only 2 parameters and a read-only annotation.

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

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

The input schema already documents both parameters thoroughly, including the accepted id forms and when workspaceId is needed. Because schema coverage is 100%, the description does not need to add much. It only implies the id refers to a publish, matching the schema's 'publish id (post_…)' description, so it adds no substantial parameter 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 the tool returns per-target status and failure reasons for one publish, giving a specific resource and what it yields. It clearly distinguishes itself from open_post by noting that for a post link, open_post is more appropriate. However, it is phrased as a fragment ('One publish: …') and could more explicitly say 'Retrieves the status of one publish.'

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

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

The description explicitly names an alternative (open_post) and the condition that selects it ('For a post link you probably want open_post instead'). This provides a clear when-not-to-use signal. It does not contrast with list tools like list_posts or list_channel_posts, but the singular scope is implied by 'One publish.'

Agents often have multiple tools that could apply. Explicit usage 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=true, and the description adds substantial non-obvious behavior: per-account values that change when settings change, the not_supported return for non-TikTok channels, and the specific fields returned. It also warns that options.tiktok.privacyLevel has no default, which is exactly the operational detail an agent needs.

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

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

Purpose is front-loaded in the first clause and the guidance is sequenced sensibly (scope, then return values, then the call-before-publish rule). The final sentence about privacyLevel is slightly long but carries required-value information that earns its place.

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

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

With no output schema, the description compensates by enumerating the returned fields (nickname, privacy levels, posting ability, video length limit) and the not_supported fallback. An agent has everything needed to call and interpret the response.

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

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

Schema coverage is 100%, so both parameters are already documented, and the description only echoes the per-account rationale for accountId and the optional nature of workspaceId. It adds no format or syntax detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (check) and resource (channel publish requirements) and immediately distinguishes itself from the sibling 'publish' by framing it as a pre-flight check. The TikTok-specific scope is spelled out, so an agent knows exactly what it is asking for.

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

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

Explicitly says 'Call it before every TikTok publish' and pre-empts the main misuse by noting that other channels return not_supported 'which is not an error to work around'. Both the when and the when-not are given.

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

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

Annotations already declare readOnlyHint=true, but the description adds valuable behavioral context: it reports live usage from the platform, and reveals an internal rate cap that can cause publish to fail independently of platform allowance. This goes beyond the basic read-only hint.

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

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

Four sentences, each serving a clear purpose: function, usage timing, differentiation from static limits, and a caveat about rate limiting. No fluff or repetition, and the most important information is front-loaded.

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

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

With no output schema, the description could have specified the return format, but it clearly conveys the core measurement (used vs. allowance) and provides context for interpreting when rate limits might still occur. The absence of an output schema is partially compensated by the description's conceptual clarity, though a bit more detail on what is returned would make it fully complete.

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

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

Schema coverage is 100% for both parameters, with clear descriptions in the schema itself. The description does not add parameter-specific semantics, so the baseline of 3 is appropriate; it does not need to compensate.

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

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

The description clearly states the tool reports how much of the 24-hour publishing allowance is used for posts, replies, and deletes. It explicitly distinguishes itself from list_platforms by noting 'not the static limits in list_platforms', making the purpose specific and unambiguous relative to sibling tools.

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

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

Provides explicit usage timing with 'Check this before a burst of publishing' and contrasts itself with list_platforms as the alternative for static limits. Also warns that publish can return rate_limited even when allowance remains, giving practical guidance for when to check quota.

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

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

Annotations already mark this as non-read-only and destructiveHint=true. The description adds valuable nuance by clarifying the action is reversible ('show it again with hide: false'), which softens the destructive hint. It does not detail permissions or broader visibility side effects, but annotations lower 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?

Two concise sentences. The action and toggle behavior are front-loaded, and every clause adds useful guidance about the hide parameter or id provenance. No wasted words.

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

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

For a simple tool with no output schema, the description plus rich schema cover the core requirements: replyId and postId derivation, the hide toggle, workspaceId handling, and post link formats. The only notable gap is not explicitly distinguishing hide from the sibling delete_post, but the reversible-toggle language 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 description coverage is 100%, so the baseline is 3. The description's mention that 'postId is the publish it belongs to' is largely redundant with the schema's own postId description. It adds little semantic meaning beyond what the schema already provides.

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

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

The description states a specific action and resource: 'Hide a reply on the channel, or show it again with hide: false.' It clearly distinguishes this from sibling tools like delete_post, reply, or list_replies by focusing on the hide/show toggle.

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

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

The description implies when to use the tool (hiding or unhiding a reply) and points to list_replies as the source for replyId. However, it does not explicitly contrast with delete_post or explain when not to use this tool, leaving some selection ambiguity.

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

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

Beyond annotations (readOnlyHint false, destructiveHint true), the description reveals idempotency with 'already: true', no unlike operation, channel limitations, cross-blog linking behavior, and the naver_not_allowed error for self-likes. This is rich behavioral disclosure with no contradiction to 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 dense yet efficient: core behavior, idempotency, no-unlike caveat, channel support, edge cases, and error behavior are all included without redundant wording. Every sentence earns its place.

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

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

Given the operation's complexity, the description covers channel restrictions, error responses, idempotency, authentication-driven cross-blog behavior, and parameter semantics. With no output schema, it sufficiently explains what an agent needs to know 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 100%, so the baseline is 3. The description reinforces that replyTo selects a reply and that links can be used for posts on another blog, but most parameter meaning is already present in the schema. It adds limited extra semantic detail.

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

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

The description states a specific action and resource: 'Like a post, or a reply under it when you pass replyTo.' It also clarifies scope by saying 'There is no unlike,' which distinguishes this tool from other engagement tools like reply or follow.

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

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

It gives explicit channel guidance ('Naver Blog only today; other channels answer not_supported') and explains idempotent behavior. It does not explicitly name sibling tools as alternatives, but the context is clear enough for an agent to know when this tool applies.

Agents often have multiple tools that could apply. Explicit usage 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. The description adds non-obvious behavioral context: the meaning of status 'active', that only active accounts are used for publishing, and that an empty list indicates no connected channel. This goes beyond the annotation without contradicting it.

Agents need to know what a tool does to the 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 adds value, starting with the core purpose, then usage context, output fields, and edge-case guidance. It is front-loaded and contains no redundancy or filler.

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

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

Despite lacking an output schema, the description explains the item fields and key statuses, integrates with the publish workflow, and covers the empty-list case with a suggested action. This is complete for a read-only list 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 description itself does not discuss the workspaceId parameter, but the schema provides a thorough parameter description including when it is needed and explicit guidance not to re-ask. With 100% schema coverage, the description adds little parameter-level meaning, earning the baseline 3.

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

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

The description clearly states this tool lists connected social accounts, enumerating fields (id, platform, handle, status). It distinguishes itself from sibling tools by explicitly positioning it as the precursor to publishing, and it is uniquely named 'list_accounts' with no similar sibling.

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

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

Explicitly instructs 'Call this before publishing anything' and explains how the output maps to publish (accountIds, only active accounts, targeting all active accounts when no channel is named). Also provides an actionable fallback when the list is empty, sending the person to the dashboard.

Agents often have multiple tools that could apply. Explicit usage 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, so the safety profile is covered. The description adds useful context by explaining the meaning of status values (blocked_window, blocked_opt_out, etc.), but it does not disclose pagination behavior, ordering, or other operational details like rate 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?

The description is compact and front-loaded with the core purpose, followed by a valuable enumeration of statuses. Each line earns its place, though the long status list could arguably be trimmed if a separate enum were available; here it is necessary.

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

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

The tool has 4 parameters, no output schema, and very low schema coverage, so the description must carry substantial weight. It covers the output's nature and status meanings but leaves pagination parameters and return details unspecified, making it incomplete for an agent to call correctly in all cases.

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

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

Schema description coverage is only 25%, so the description must compensate, but it only implicitly clarifies that 'id' refers to the automation. The 'limit' and 'before' pagination parameters are left entirely unexplained, and workspaceId's purpose is defined only in the schema, not the description.

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

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

The description clearly identifies the resource (runs of one automation) and the output (status and step log), and the title supplies the verb 'List'. It differentiates from siblings like list_automations and get_automation by specifying 'one automation', though the description itself is a noun phrase rather than a full verb-led statement.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 list_automations or get_automation. The status meanings imply use for inspecting run history, but there is no stated context, prerequisites, or exclusions.

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

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

readOnlyHint already signals a safe read, and the description adds useful context about the summary fields and connected-account scope. It does not disclose potential pagination, ordering, or error behavior, so it adds modest but not rich behavioral detail beyond annotations.

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

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

Two tight sentences: the first front-loads what is returned and the second names the relevant alternative. Every word earns its place.

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

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

For a simple read-only list tool with one optional, fully documented parameter, the description covers purpose, scope, returned fields, and the main sibling alternative. No output schema is needed because the field list is in the description.

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

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

The sole parameter workspaceId is documented with a detailed schema description, achieving 100% schema coverage. The tool description itself adds no parameter information, so the baseline of 3 applies.

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

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

The description clearly defines the tool as returning automations on connected accounts and enumerates the returned fields (name, channel, live/draft, triggers, run count). It also distinguishes itself from get_automation, which reads one flow's document, so an agent can tell them apart.

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

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

It explicitly tells the agent to use get_automation when the need is to read one flow's document, implying list_automations is for the summary list across connected accounts. This provides a clear decision rule between siblings.

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

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

The readOnlyHint annotation already signals a safe read operation, and the description adds useful behavioral context: each template lists its parameters and supported channels, and the comment_to_dm example illustrates the interaction flow. This gives the agent a concrete sense of what the returned templates describe without contradicting the annotation.

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

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

The description is compact and front-loaded, leading with the core purpose then adding usage guidance and a clarifying example. Every sentence contributes value, and the comment_to_dm example is relevant without being excessive.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description covers the key things an agent needs: what the tool returns, when to call it, and a representative template example. It could theoretically mention that no output schema is provided, but this is not necessary given the straightforward nature of the tool.

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

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

Schema description coverage is 100% and the single optional workspaceId parameter is already well explained in the schema, including when to omit it. The description adds no parameter-specific guidance, but the baseline of 3 applies because the schema carries the full burden and does so adequately.

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

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

The description clearly states the tool lists ready-made automation templates with their parameters and channels, which is specific and actionable. It does not explicitly contrast itself with list_automations, but the term 'templates' versus 'automations' and the reference to create_automation make the purpose 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 explicitly instructs agents to read this before create_automation, giving a clear when-to-use signal. It does not mention alternatives like list_automations or when to skip this tool, but the primary usage context is well established.

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

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

Annotations only declare readOnlyHint, so the description carries the burden of behavioral nuance and does it well: it warns that an empty result does not mean the account has no posts, and explains the TikTok-specific reason (public-videos-only reads while the Content Posting audit is pending, with posts going out private). That is exactly the kind of non-obvious behavior that prevents a wrong diagnosis.

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

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

Three sentences, each doing distinct work: identifying the resource, giving the use condition plus downstream chaining, then the empty-result caveat. The caveat sentence is long but front-loads the actionable fact (empty does not mean no posts) before the TikTok rationale, so it earns its length.

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

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

With no output schema, the description compensates by telling the agent what each returned item carries (a permalink usable by other tools) and by scoping the result set to live channel content. Pagination behaviour beyond the documented limit parameter is the only real gap, and that is minor for a read-only listing tool.

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

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

Schema description coverage is 100%, so limit, accountId and workspaceId are already fully documented in the schema, including the defaults and the multi-workspace disambiguation hint. The description adds nothing about parameters, which is acceptable at this coverage level but earns no extra credit.

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

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

The description states a specific resource and scope — what is currently live on the channel, including posts composed in the channel's own app — which an agent can distinguish from a link-based fetch like get_post. It stops short of explicitly contrasting itself with the sibling list_posts, so the differentiation is inferred from the 'right now / actually on the channel' framing rather than stated.

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

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

It gives a clear selection condition ('use this to find a post when you do not have its link') and names the downstream tools that consume the returned permalink (open_post, reply, delete_post). What is missing is the converse case — when to prefer list_posts or get_post instead — so the guidance is clear but not exhaustive.

Agents often have multiple tools that could apply. Explicit usage 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 annotation already establishes safety, so the description adds value by disclosing that each item reports whether the 24-hour window is open and how much time remains. This is useful behavioral/return information beyond what annotations or schema 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?

Three short sentences with no filler; the opening 'The inbox' orients the agent immediately, and the filter hints and item-level behavior are stated efficiently. Every sentence contributes.

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

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

With no output schema and 7 parameters, the description covers the core concept and one important return detail but omits guidance on filtering via search/unread, pagination via limit, and account selection. It is minimally sufficient but leaves meaningful gaps for a 7-parameter tool.

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

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

Schema description coverage is only 14%, so the description must compensate for undocumented parameters. It does clarify state's default ('open') and maps kind to the conversation types mentioned earlier, but limit, search, unread, accountId, and workspaceId receive no explanatory value 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?

States a specific verb ('list') and resource ('inbox conversations'), and clearly defines the scope: DMs on Instagram/Facebook plus mention threads on Threads. This distinguishes it from sibling tools like read_conversation or list_mentions, which focus on individual messages or mentions only.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 as an inbox overview and mentions state/kind filters, which gives some context on how to use it. However, it does not explicitly say when to prefer this tool over alternatives like list_mentions or read_conversation, nor does it state exclusions.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds that mentions are delivered by webhook and that the result shape matches list_conversations, which is useful context. It does not go further into auth requirements, rate limits, or pagination, but for a read-only list tool 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 sentences, no wasted words, and the core purpose is front-loaded. The mention of same-shape and the send_dm follow-up both earn their place by giving the agent actionable orientation.

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

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

With no required parameters and readOnlyHint=true, the tool is simple enough that the description covers the main context: what is listed, how it relates to list_conversations, and what to do with the results. There is no output schema, so the 'same shape' reference is important and mostly sufficient, though unread semantics remain unexplained.

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

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

Schema description coverage is only 33%, with workspaceId described in the schema but accountId and unread left undocumented. The description does not compensate for this gap: it never mentions unread, accountId, or how they affect the results. The 'same shape as list_conversations' line is too indirect to clarify parameter behavior.

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

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

The description clearly states what the tool does: it returns Threads posts that mention the connected account. It also distinguishes itself from list_conversations by noting it is the same shape but filtered with kind mention. This is enough for an agent to understand its specific role among many list 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 reference to list_conversations implies when this tool is appropriate, and 'Reply with send_dm' gives a useful follow-up action. However, it does not explicitly state when not to use this tool or compare it against other list alternatives like list_posts or list_channel_posts. The usage context is implied rather than explicit.

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

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

The description goes well beyond the readOnlyHint annotation by spelling out the meaning of status values (live, beta, bridge, soon), how charCount should be interpreted, and that options is the JSON Schema for publish options. This is substantial behavioral disclosure 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?

The description is organized around the key fields and is mostly front-loaded, but it repeats 'Read it instead of guessing' twice, which is slightly redundant. Still, each substantive sentence adds meaning to the tool's output.

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

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

Given the lack of an output schema, the description explains the important field semantics (status, charCount, options) but does not detail the media-related fields (media required, image/video limits) mentioned in the first sentence. This is a minor gap, but the core decision-making data is covered.

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

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

The input schema already documents workspaceId with a full explanation about when to include it and when to omit it, so schema coverage is 100%. The tool description adds nothing about the parameter, so the baseline score of 3 applies.

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

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

The description states the tool lists every channel and its rules (character limit, media requirements, state) and explicitly frames it as the way to avoid guessing platform limits. It is specific about the resource and what it returns, but does not name sibling tools to differentiate it, so it stops short of full distinction.

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

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

The description says to read this instead of guessing a platform's limits, and connects charCount to checking length before calling publish, giving a clear context of when to use it (before publishing). However, it does not mention when not to use it or alternatives like get_publish_options.

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

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

Annotations only declare readOnlyHint: true. The description adds substantial behavioral context beyond that: default limit (20), max 100, pagination via hasMore/nextBefore, the fact that sort=scheduled drops paging, and the workspaceId fallback behavior. It also clarifies that scheduled posts are dated by scheduledAt and sent posts by creation time. No contradictions.

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

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

The description is a dense, single paragraph with no filler. It leads with the core purpose, then covers inclusions, ordering, defaults, pagination, and the sibling distinction in a logical order. Every sentence contributes operational knowledge.

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

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

For a list tool with 7 parameters, no output schema, and no required params, the description covers everything needed: what's returned, ordering, paging, filtering, and the workspaceId edge case. It also disambiguates from the sibling. An agent can call this tool correctly without further clarification.

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

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

Schema description coverage is 100%, so all parameters are individually documented. The description adds value by explaining the default limit, the interaction between sort and paging, and the semantics of 'before' as nextBefore from a previous page. It also clarifies the workspaceId condition. This goes beyond simple restatement, though not every nuance is covered, so a 4 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 states a specific verb ('list') and resource ('posts published through us'), and precisely scopes what is included (recent publishes, scheduled and draft posts) and what is excluded (posts that existed on the channel). It explicitly names the sibling list_channel_posts as the alternative, distinguishing the two clearly.

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

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

It gives explicit when-to-use guidance with a concrete example ('To answer "what is scheduled this week", pass status scheduled with since and until and sort scheduled') and explicitly points to list_channel_posts for channel-existing posts. No ambiguity about when to choose this tool.

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

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

The readOnlyHint annotation already signals safety, and the description adds valuable behavioral detail: the result includes nested replies, may be truncated, and the returned count can differ from the get_insights metric. This gives the agent useful expectations beyond the annotations.

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

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

The description is three short sentences, each adding meaningful information: what is returned, how truncation is signaled, and how the count relates to another tool. There is no redundancy or filler.

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

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

For a read-only list operation with only two parameters and no output schema, the description covers the key behavioral semantics: full nested thread, truncation, and count discrepancies. It does not explain how to continue after truncation, but that is not critical for the 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?

The schema already documents both parameters fully, including how `id` can be a publish id, channel id, or link, and when `workspaceId` is needed. The description adds no parameter-level details, so the baseline of 3 is appropriate given the high 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 clearly identifies the tool as returning the full reply thread under a post, including nested replies. The title and description align, and the relationship to get_insights is clarified enough to distinguish 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 for when to use this tool: when you need the whole reply thread, not just a metric. It explicitly notes that the reply count here may differ from the get_insights metric, which helps prevent misuse, though it does not explicitly name alternatives or state when not to use it.

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

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

Beyond the annotations, the description adds meaningful behavioral context: it verifies that the file actually landed before marking it ready, and only a ready id can be sent to publish. This tells the agent the tool is not a blind completion step and that readiness is gated. It does not contradict the readOnlyHint/destructiveHint annotations.

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

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

Three short sentences, each earning its place: what step it is, when to call it, and what behavioral guarantee it provides. Important sequencing information is front-loaded.

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

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

For a simple two-parameter tool with annotations and full schema coverage, the description covers the workflow context, the prerequisite, and the downstream consequence well. It does not describe what the response looks like or how failure is reported if the file did not land, which is a minor gap given there is no output schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The id and workspaceId parameters are already well documented in the schema, including the conditional need for workspaceId. The description itself adds no additional parameter-level meaning.

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

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

The description clearly identifies the tool as the completion step in a media upload workflow, using a specific action ('Call it after the upload finishes') and resource ('image or video'). It distinguishes itself from sibling media tools by framing this as the step that marks an upload as ready, and it names the downstream dependency on publish.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 timing guidance: call it after upload finishes and before passing a ready media id to publish. It does not explicitly name alternatives like media_upload_status or media_presign, so it stops short of full when-not-to-use guidance.

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

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

Annotations already indicate this is not read-only, and the description adds meaningful behavioral context: the tool downloads the file, copies it into storage, and returns a media id. It also discloses the https-only constraint and the share-link failure mode, going beyond the structured fields.

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

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

The description is compact and front-loaded: the main action appears first, followed by necessary constraints. Every sentence contributes either to usage guidance or parameter clarification, with no redundancy.

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

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

With no output schema, the description correctly states the outcome (media id for publish). It covers URL requirements, failure cases, and altText guidance. Minor omissions like size limits or processing time are not critical for a simple tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra value by specifying that the URL must be a direct file URL ending in the file itself, and by advising to write altText when an image is visible. This goes beyond the 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 states a specific verb and resource: 'Attach an image or video that is already on the public web.' It explains the process (download, copy to storage, return a media id) and how it differs from publishing, 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?

Provides clear context: use this when media is already on the public web ('One step, no upload needed') and explicitly warns which URL types won't work (Google Drive/Dropbox share links). However, it does not name the upload alternatives among the siblings, leaving the when-not-to-use case partly 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 only declare it is a non-read-only, non-destructive write; the description carries the real behavioral load: the uploadUrl is one-time, the correct contentType must be reused on the PUT, and the media id expires at mediaExpiresAt so a later publish fails with media_expired. That expiry/failure semantics is exactly the kind of context annotations cannot express.

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

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

Front-loaded with the step number, the return values, and the next action, then constraints — a good ordering for an agent. Slight redundancy: the contentType list and part of the altText guidance duplicate the schema descriptions rather than adding to them.

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

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

With no output schema, the description itself names the returned media id, uploadUrl and mediaExpiresAt, and explains the failure mode on expiry. For a 7-parameter tool with 3 required fields, the workflow, constraints and error behavior are all covered.

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

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

Schema coverage is 86% (baseline 3), and the description adds genuine constraints the schema lacks: per-type byte ceilings (20MB image / 8GB video), 43200-second and 4096px video limits, and a 20:1 aspect-ratio cap. It also reinforces altText usage ('write altText describing it'), though the contentType list largely repeats the schema enum text.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Step 1 of attaching an image or video') plus concrete outputs ('Returns a media id and a one-time uploadUrl'), which cleanly separates it from the sibling media_complete that finishes the flow. An agent can route between media_presign, media_complete, media_from_url and media_upload_link from this text alone.

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

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

Gives an explicit follow-up procedure ('PUT the file bytes to uploadUrl ... then call media_complete') and the per-media-type eligibility rules, so the agent knows the sequencing and constraints. It never explicitly says when to prefer this over media_from_url or media_upload_link, so it falls short of a full when/when-not 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?

Beyond the readOnly/destructive annotations, the description reveals that the link is short-lived, that the operation is asynchronous, and that publishing before the status is ready is forbidden. This is meaningful behavioral context that annotations do not convey.

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

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

Every sentence earns its place: purpose, return, workflow, warning, and alternative. The critical sequencing instruction is bolded and front-loaded, making it stand out clearly for an agent.

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

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

Despite having no output schema, the description tells the agent what it returns (a short-lived link), how to proceed (poll status with the token), and what to do with the result (call publish with the media ids). It also names the relevant sibling tools and covers the full lifecycle needed 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?

The schema already documents note and workspaceId with 100% coverage. The description adds extra practical meaning for workspaceId: only needed for multi-workspace accounts, can be omitted when already decided, and should not be re-asked. This goes beyond the schema but does not need to elaborate on note because the schema covers it.

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

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

The description states a specific verb and resource: create an upload link that asks a person to upload files from their own device. It clearly distinguishes this from media_from_url, which is for files with a public https address, and from related siblings like media_upload_status.

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

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

It gives an explicit when-to-use rule and names the alternative: use this when the file is on the person's computer/phone, use media_from_url for public URLs. It also provides a precise multi-step workflow: give the link, wait, poll media_upload_status, and only then call publish.

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

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

Annotations only say readOnlyHint=true; the description adds rich behavior: possible statuses, media ID lists, image blocks via previewIds, 20-item pagination, offset usage, and the duplicateOf deduplication hint. This goes far beyond the structured annotation.

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

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

The description is dense but every sentence earns its place: status values, output usage, visual previews, pagination, and the duplicateOf edge case. It is front-loaded with the core question and status list before diving into mechanics.

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

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

With no output schema, the description fully explains return semantics: statuses, mediaIds, previewIds mapping, pagination, and duplicate handling. Nothing an agent needs to invoke the tool correctly or interpret results is missing.

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

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

Schema coverage is 100%, so the schema already documents all three parameters. The description adds helpful context for token ('from media_upload_link') and offset ('to see the rest'), but does not substantially enrich workspaceId beyond its 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 opens with a direct question ('Has the person uploaded yet?') and clearly states the resource: upload status for a token from media_upload_link. It returns explicit statuses (waiting, ready, expired) and media IDs, distinguishing it from sibling tools like media_upload_link or publish.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 workflow: call this after media_upload_link, then pass returned IDs to publish as mediaIds. It explains when and how to use the output, but it does not explicitly exclude alternatives or name 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 readOnlyHint=true, and the description adds meaningful behavioral detail: text never changes, photos without media references get auto-placed, and layout transformation follows the selected preset. It also clarifies that the server never makes the form decision, which is important non-obvious 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 dense and front-loaded with the core purpose, and every clause adds operational detail rather than filler. However, it is a single long paragraph with several intertwined workflow branches, so it could be tightened or broken into shorter sentences for easier scanning.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 preview tool with no output schema, the description covers the full call flow: what to pass, what to expect (layout vs layouts[]), how to use the result with publish, and how to bypass the transform with 'as-is.' It also handles the multi-account workspaceId edge case, so an agent can invoke it correctly without additional lookups.

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

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

Schema description coverage is 100%, so the baseline is 3; the description adds operational context by linking content and mediaIds to the eventual publish call and clarifying when workspaceId is needed ('only when the account has more than one'). It also explains the relationship between form and forms, though most parameter details are already present in the schema.

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

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

The description opens with 'Naver Blog only' and 'Shows how publish will lay the body out before anything goes out,' naming a specific verb, resource, and platform scope. It distinguishes itself from publish by explaining that it is a preview that does not send content.

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

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

It gives an explicit workflow: call with the same content and mediaIds before publishing, show the result, then either publish with the same layout or pass layout 'as-is' to bypass reshaping. It also explains when to use forms: 'all' to let the person choose, and it states the server never picks, leaving the decision to the 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 readOnlyHint annotation is present and the description is consistent with it. The description adds useful behavioral context beyond the annotation by warning that replies or metrics can come back null if the platform refused just that part, which helps set expectations about partial responses.

Agents need to know what a tool does to the 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, purposeful sentences. It front-loads the core purpose, then gives the primary use case, then a caveat about partial nulls. There is no filler or redundant repetition of 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?

For a read-only single-post tool with no output schema, the description provides the essential return shape (text, thread, metrics), the main invocation trigger (a post link), and partial-failure behavior. It could be slightly more complete by describing what metrics are included, but beyond that an agent has enough context to select and call it correctly.

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

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

Schema description coverage is 100%, and the schema already thoroughly documents both id and workspaceId, including accepted formats and optionality. The description adds little parameter-level meaning beyond reinforcing the post-link use case, so the baseline of 3 is appropriate.

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

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

The description clearly states what the tool does: it returns the text, entire reply thread, and metrics for a single post in one call. This distinguishes it from sibling tools like get_post, list_replies, and get_insights by combining their functionality into one unified 'open post' operation.

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

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

The description gives a concrete, actionable trigger: 'This is the right tool when someone hands you a post link.' It does not explicitly mention when not to use it or name alternatives, but the stated use case is clear enough for an agent to make a basic routing decision.

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

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

Annotations only say readOnlyHint=false and destructiveHint=true, which is minimal. The description carries the burden and does so thoroughly: it discloses that Naver rate limits return 429 with retryAfterSeconds and that the draft is already in Naver; that offline/logged_out bridge states mean the post is queued and must be relayed to the user as not-published; that over-limit text publishes nothing to any channel; that the call returns before publishing completes with permalink null; and that YouTube privacyStatus may not be what was requested. All of this adds genuine behavioral context far beyond the annotations.

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

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

The description is long, but nearly every sentence earns its place for a 12-parameter multi-channel tool with no output schema. Facts are grouped by channel and concern (limits, grouping, Naver specifics) rather than dumped as one undifferentiated paragraph. A couple of redundancies appear – Naver form and media: references are explained both in the main description and in the schema's naver_blog block – but the main-body repetition is justified because it is the operative instruction for the agent.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 12 parameters, nested per-channel options, no output schema, and 44 sibling tools, the description is remarkably complete. It covers text limits, media grouping, error codes and how to recover, the bridge/offline path, scheduling, draft mode, per-channel content overrides, threadItems as an alternative to reply, and when to consult get_post, get_publish_options, list_accounts, describe_grammar, naver_layout, and update_post. Nothing an agent needs to safely invoke this multi-channel publish is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description compensates with information that is not in the schema: where media ids come from, how Naver form selection works, the exact retry/error codes, per-channel text limits and item grouping, the fact that channel content overrides shared content, and the scheduledAt/draft semantics. It also tells the agent to pass the Naver Markdown body in options.naver_blog.content when other channels are present, which the schema's description mentions but the tool description makes operative.

Input schemas describe structure but not intent. Descriptions should explain 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 'Post to social channels' – a specific verb and resource – then immediately lists the exact channels open today. It distinguishes itself from siblings like update_post, delete_post, publish_now, and reply by covering immediate multi-channel publishing, and from select_channels by telling the agent where accountIds must come from.

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

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

The description is explicit about when to use publish versus alternatives: 'Get accountIds from select_channels — do not guess which channel the person meant', 'For a long post use threadItems instead of publish-then-reply', and it names update_post, publish_now, delete_post, retry_post, and get_post in the contexts where they apply. It also states when not to call again (Naver 429) and when to show forms instead of picking.

Agents often have multiple tools that could apply. Explicit usage 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 only say readOnlyHint=false and destructiveHint=true; the description adds the meaningful behavioral details: it returns while publishing, wait controls synchronous behavior, drafts need a target account, and already-sent posts return post_not_editable. This is exactly the kind of operational context an agent needs beyond the raw annotations.

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

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

Three sentences with no filler. The main action is front-loaded, then the async behavior, then the preconditions and failure mode. Every sentence contributes information an agent cannot infer from the schema alone.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 3-parameter action with no output schema, the description covers the key operational concerns: async versus blocking behavior, draft requirements, error semantics, and id/workspace disambiguation. Referencing 'like publish' is acceptable because publish is a known sibling that documents the shared return semantics.

Complex tools with many parameters or behaviors need more documentation. 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, but the description adds real value: it explains the accepted id forms (publish id, channel id, or post link), clarifies that wait behaves 'same as on publish,' and tells the agent to omit workspaceId unless multi-workspace and not to re-ask the person. That meaningfully extends the schema.

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

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

The description opens with a specific verb and resource: 'Send a scheduled or draft post right now instead of waiting.' It clearly distinguishes this from the broader publish/update/retry sibling family by focusing on immediate publication of scheduled or draft content.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 usage context: use this when you want a scheduled or draft post sent immediately, and pass wait: true if you need to block for the result. It also flags draft prerequisites and the already-published error case. It references 'like publish' but does not explicitly state when to prefer publish_now over publish, so it stops short of full alternative routing.

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

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

Annotations declare destructiveHint=true and readOnlyHint=false. The description adds context about version conflict behavior, validation paths, and that changing a live flow affects people. It does not contradict the annotations and provides meaningful behavioral detail beyond the flags.

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

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

The description is dense and logically ordered: purpose, version requirement, node types, waiting semantics, validation, and impact. Every sentence adds value, though it is somewhat long. It is well structured and front-loaded with the core purpose.

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

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

For a complex tool with a large schema, the description covers the essential usage nuances: versioning, node types, waiting/loop rules, and validation behavior. It does not describe return values, but there is no output schema, so that is acceptable. It is sufficient for an agent to call 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 40%, so the description must compensate. It clarifies the version parameter and explains the doc structure (node types, waiting, loops). However, it does not elaborate on id, name, or workspaceId, leaving gaps that the schema only partially fills.

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

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

The description states a clear action: 'Replace an automation's whole document.' This is a specific verb and resource. It distinguishes from partial updates and creation implicitly, but does not explicitly name alternative tools like create_automation, so it misses the top score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 concrete usage rule: 'Pass the version you got from get_automation; a stale version is refused with version_conflict.' This guides when to use it and how to avoid conflicts. It does not explicitly state when not to use it (e.g., for creation), but the instruction is actionable.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds useful behavioral details: it returns recent messages only, includes contact fields like tags/opt-out, notes Instagram-specific follow status, and explains that AI drafts appear as 'draft' status.

Agents need to know what a tool does to the 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 tight sentences with no filler. The core purpose ('one conversation with its recent messages and the contact') is front-loaded, and the draft-status note is a valuable addition without bloating the text.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 read-only and has no output schema, the description does a good job outlining return contents and special cases. It could be more explicit about what 'recent messages' includes or any pagination, but the provided detail is sufficient for an agent to call it correctly.

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

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

Schema coverage is 50%: the workspaceId parameter is already well explained in the schema, and id is self-evident as the conversation identifier. The description does not add parameter-level meaning, but the schema handles the only ambiguous parameter, leaving no meaningful gap.

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

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

The description clearly states the tool reads a single conversation and returns its recent messages plus contact details. It is specific about the resource and scope, though it does not explicitly name sibling tools like list_conversations or get_contact to differentiate 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?

No guidance is given on when to use this tool versus alternatives. It implies use when you need one conversation's recent messages and contact info, but it does not mention list_conversations for browsing multiple conversations or get_contact for contact-only details.

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

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

With annotations only marking readOnlyHint=false/destructiveHint=false, the description carries the real behavioral load: waits up to a minute via the browser extension, returns 202 when the extension is offline and defers the refresh, and returns refresh_unsupported for other channels. This is exactly the async/latency/error context an agent needs.

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

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

Front-loads purpose, then channel-specific behavior, then the trigger condition and error cases, in four tight sentences with no filler. 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?

No output schema, but the description explains the meaningful return states (202 deferral, refresh_unsupported, and where refreshed data appears). Nothing needed to call this correctly is missing.

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

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

Schema coverage is 100% — both accountId and workspaceId are already documented, including the nuanced workspaceId guidance — so the description adds little parameter detail. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb ('re-read') and resource ('one connected channel's metadata'), and grounds it in the sibling flow (list_accounts shows the refreshed list). An agent can distinguish this from list_accounts or publish without opening a 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?

Explicit trigger: 'Call this when a category the person mentions is not in list_accounts yet.' It also states the negative case — other channels return refresh_unsupported because their metadata is live on every call — so when-not-to-use is covered.

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

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

The description discloses the asynchronous behavior ('returns before the reply is live') and directs the caller to get_post with the returned id. This adds value beyond the annotations, which only mark the operation as non-read-only and hinting at mutation. No contradiction with the annotations is present.

Agents need to know what a tool does to the 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-loads the core purpose. Every clause contributes; the mention of 'Like publish' is brief but meaningful. A small formatting gap after the period slightly disrupts readability but does not harm comprehension.

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

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

For a mutating reply operation with no output schema, the description explains the main flow, the return id usage, and how to check final status. It could additionally state the expected response shape or call out channel-specific constraints, but the provided guidance is sufficient for most calls.

Complex tools with many parameters or behaviors need more documentation. 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 roughly 80%, so the schema carries most parameter meaning. The description adds useful semantics for replyTo (empty vs. reply id from list_replies) and subtly confirms id can be a publish id. Content, secret, and workspaceId are left to the schema, which is acceptable at this coverage 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 states a specific verb and resource: 'Reply to a post or to a reply.' It clearly distinguishes this from sibling tools like publish, list_replies, and hide_reply by narrowing the operation to replies and nesting behavior.

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

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

The description gives concrete usage guidance: leave replyTo empty for a top-level reply, or pass a reply id from list_replies to nest. It also explains how to verify completion via get_post after the async return. It does not explicitly contrast with publish or other alternatives, but the context is clear enough for an agent to decide.

Agents often have multiple tools that could apply. Explicit usage 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 destructive and not read-only. The description goes well beyond that by disclosing replay behavior, the 429 naver_rate_limited response with retryAfterSeconds, the 400 naver_form_required response, the nothing_to_retry case, and the risk that a failed Naver Blog target may still have left a post or draft. No contradiction with annotations.

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

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

The description is dense and long, yet nearly every sentence carries an operational constraint or edge case that matters for correct invocation. It is front-loaded with the core purpose. It could be restructured into shorter sentences for readability, but it is not padded.

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

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

For a destructive retry operation with no output schema, the description covers prerequisites, failure modes, when not to call, what can go wrong on Naver Blog, and how to resolve form-required errors. An agent has enough context to invoke it correctly and safely.

Complex tools with many parameters or behaviors need more documentation. 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 describes id and workspaceId, so the baseline of 3 applies. The description adds workflow-level semantics about options.naver_blog.form and layout, but these are not present in the provided input schema, which is a slight mismatch; it does not add extra meaning to the two actual 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?

States a specific verb and resource: 'Retry the targets that failed on a publish.' It is clearly differentiated from siblings like publish or publish_now by scoping to failed targets and noting that already-successful targets are left alone.

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

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

Provides explicit when-to-use and when-not-to-use guidance: check get_post for retryable, call publish again instead when retryable is false, do not call before retryAfterSeconds, and only applies to posts published through this system. It names the alternative tool and the condition for choosing it.

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

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

The description discloses detailed behavioral traits beyond the readOnlyHint annotation: duplicates are folded, expired/not-yet-live channels are dropped into `skipped` with reasons and reconnect links, `limits` reflects the tightest rule, and accountIds are to be passed to publish unchanged. It also explains the Naver Blog bridge state and queued info, and instructs to relay userMessage. This exceeds the annotation's basic read-only hint and provides actionable context.

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

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

The description is fairly long but dense with necessary information. It is front-loaded with the core purpose and critical instruction, then expands on scope and edge cases. Every sentence contributes meaning, though it could be tightened slightly. It is well-structured and not redundant.

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

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

With no output schema, the description fully explains return values (accountIds, candidates, skipped, limits, and Naver Blog's bridge, state, userMessage, queued) and how to use them. It also covers the empty-result case and reconnection flow, making it complete for an agent to execute correctly. The complexity is high and the description addresses all relevant aspects.

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

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

Schema coverage is 100%, so the schema already documents both parameters (scope and workspaceId) with clear descriptions. The description adds behavioral context about scope (duplicates folded, skipped channels) but does not add new parameter format details beyond what the schema states. Baseline 3 is appropriate given the schema does the heavy lifting; the description does not meaningfully augment parameter semantics.

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

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

The description states a specific verb and resource: 'Pick which connected channels to post to.' It also clarifies its role as a prerequisite to publish ('Call this before publish'), which distinguishes it from the sibling publish tool. It also explains the two modes (candidate listing vs selection), making its 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?

The description gives explicit when-to-use guidance ('Call this before publish and show the result to the person'), how to use the scope parameter (omit for candidates, 'all' for all active, or a mixed array), and when to direct the user to connect channels ('If both accountIds and candidates come back empty... Send the person to...'). It also specifies handling of Naver Blog bridge states, covering exclusions and 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?

The description significantly exceeds the annotations by disclosing side effects (automations paused for 30 minutes), special behavior on mention threads (public reply), refusal behavior (window_closed), and the draft-approval flow. This gives an agent a clear picture of what actually happens when the tool is called.

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

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

The description is compact, front-loads the primary action and the most critical constraint (24-hour window), then covers secondary behaviors in separate sentences. There is no filler, and every sentence contributes actionable information.

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

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

Given the absence of an output schema and the tool's mutating nature, the description covers the key behavioral context: when it succeeds, when it fails, side effects, and draft usage. It does not describe the success response shape, but the critical error case is named, making it sufficiently complete 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 80%, so the schema itself documents most parameters. The description adds useful context for draftId ('AI draft that was waiting for approval') but does not explain text, mediaId, or workspaceId beyond the schema. It meets the baseline but does not substantially compensate for the 20% gap.

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

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

The description clearly states the action ('send a message in a conversation as the account') and specifies important scope details like the 24-hour window and mention-thread behavior. It does not explicitly distinguish this from sibling tools like reply or create_comment_to_dm, so it misses the last bit of differentiation.

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

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

It gives explicit usage conditions: only inside the 24-hour window, otherwise the call is refused with window_closed, and draftId is for sending AI drafts awaiting approval. It does not name alternative tools or say when to choose those over this one, but the window constraint strongly shapes when this is appropriate.

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

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

Annotations only declare readOnlyHint=false and destructiveHint=false, leaving safety profile minimal. The description goes far beyond this: it discloses the 429 naver_rate_limited retry behavior, the 400 naver_form_required condition, the in-place rewrite of published Naver posts (same URL/logNo), and the field-level semantics (left-out fields keep value, options replaces whole object). It also explains the 'missing image' fix. No contradictions with annotations.

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

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

The description is very long and not front-loaded; the first sentence leaps from general purpose to Naver rate limiting before explaining core behavior. Multiple topics (rate limits, form handling, layout, published posts, parameter semantics) are interleaved, making it harder to parse. While nearly every sentence carries unique information, the lack of organization and excessive length pull the score down.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 8 params, nested objects, and no output schema, the description covers a large range of edge cases: rate limiting, form requirements, layout options, thread limitations, and non-editable post errors. It omits only an explicit statement of the success return value, which is a minor gap given the focus on invocation. Overall it is sufficient for correct usage.

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

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

Although schema coverage is 100%, the description adds critical semantics not present in the schema: concrete behavior when fields are omitted (keep current), options replacement semantics, scheduledAt null/draft behavior, thread-only schedule changes, and the need to relist mediaIds to keep photos on Naver published posts. It also explains the layout option ('as-is') and form selection flow, which massively benefits the agent.

Input schemas describe structure but not intent. Descriptions should explain 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 'Change a scheduled or draft post before it goes out' and specifies the mutable fields (content, mediaIds, accountIds), clearly distinguishing this from sibling tools like publish (create) and delete_post (remove). It also clarifies the scope by noting that already-published posts are generally not editable except for Naver Blog's in-place rewrite, which further defines 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?

While it doesn't name alternative tools explicitly, it provides strong when-not guidance: 'Posts that already went out return post_not_editable' and 'A thread only takes schedule changes.' It also gives conditional instructions like not calling again before retryAfterSeconds, and how to handle the Naver form selection. Missing explicit pointer to siblings like 'use publish for new posts' keeps it just below a 5.

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