Viral Manager

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

No annotations are present, so the description must carry the behavioral burden. It usefully discloses that the note is visible to the whole team and authored by the MCP key's user, adding important auth and visibility context. It stops short of explaining error behavior or whether the note appends to an existing thread rather than creating a new one, but the core side effects are clear.

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

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

Two sentences with no wasted words; the action is front-loaded and the second sentence adds only high-value behavioral context. 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 two-parameter write operation, the description covers the action, target, visibility, and authorship. It omits return values or error messages, but with no output schema and no nested objects, this is acceptable and does not leave the agent with critical ambiguity.

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

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

With 100% schema description coverage, post_id and content are already documented in the schema. The description adds no parameter-specific details beyond what the schema provides, 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?

Description uses specific verb 'Add' with resource 'note to the team's thread on a post', clearly distinguishing from sibling read tools like list_post_notes. It also states visibility and authorship, making the operation 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 implies the use case (adding a note to a post's team thread) but never explicitly says when to choose this over alternatives such as list_post_notes or tag_posts. No exclusions or preconditions are mentioned, relying on the agent to infer the appropriate context.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It reveals meaningful constraints: requires an active subscription and enforces the plan's account limit. It does not mention duplicate handling or response behavior, but the key non-obvious requirements 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 two concise sentences with no filler. The action and purpose are front-loaded, followed by the important prerequisites. Every sentence adds value.

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

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

For a single-parameter tool with no output schema, the description is largely complete: it states the action, purpose, prerequisites, and a constraint. It could have described what happens on duplicate accounts or when the plan limit is reached, but these are minor gaps given the tool's simplicity.

Complex tools with many parameters or behaviors need more documentation. 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 fully documents the username parameter, including accepted formats. The description adds no additional parameter-level detail beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Add') with a clear resource ('Instagram account to the user's watchlist') and explains the purpose ('so its viral posts get detected automatically'). It is clearly distinguishable from sibling tools like remove_watchlist_account and list_watchlist_accounts.

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

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

The description gives clear usage context by stating prerequisites: an active subscription is required and the plan's account limit is respected. It does not explicitly name alternatives or say when not to use it, but the context is enough for an agent to understand the basic invocation conditions.

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

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

With no annotations provided, the description fully carries the behavioral disclosure burden. It discloses credit cost, subscription requirement, the async execution model, and the polling pattern with terminal statuses 'completed' or 'failed'. This is strong transparency for a paid, async operation.

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

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

The description is three sentences with no fluff. It leads with the primary action, then immediately covers cost and subscription constraints, then explains the async polling flow. Every sentence contributes essential 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?

Even without an output schema, the description provides a complete enough contract for calling the tool: it tells the agent what to expect (a post id), how to track progress (poll get_post_analysis), and what terminal states to watch for. The cost and subscription prerequisites are also 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 schema already describes the url parameter with concrete examples, and there is only one parameter. The description adds no parameter-specific meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states a specific action: importing an Instagram or TikTok post URL and running AI virality analysis on it. It also sets expectations for how it relates to the polling sibling get_post_analysis, making the tool's role easy to distinguish.

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

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

The description gives clear context for when to use the tool: when a post URL needs virality analysis. It explicitly references get_post_analysis for polling results, but does not discuss alternatives such as checking list_analyzed_posts first to avoid spending a credit on an already-analyzed post.

Agents often have multiple tools that could apply. Explicit usage 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 no annotations, the description carries the full behavioral burden and succeeds: it discloses cascading to each subtree, ancestor restoration on restore, and reversibility. These are non-obvious side effects an agent needs before invoking.

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

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

Three short sentences, front-loaded with the core operation and each sentence adding a distinct fact: batch scope, cascade/ancestor behavior, and reversibility contrast. No filler or repetition.

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

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

For a mutation tool with no annotations and no output schema, this description covers what the operation does, how the batch should be constructed, side effects on subtrees and ancestors, and when to prefer it over delete_folder. An agent has enough context to invoke it correctly.

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

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

The description adds meaning beyond the schema: folders should be week folders passed together in one call, and the action choice changes cascade behavior. The schema covers accepted identifier formats, so the description complements rather than duplicates it.

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

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

States a specific verb and resource: 'Archive (or restore) SEVERAL assignment folders in ONE call,' making the batch scope explicit. The phrase 'Reversible (unlike delete_folder)' directly differentiates it from the destructive folder-deletion 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?

Gives a concrete use case ('Typical weekly reset: pass every week folder at once') and names the alternative delete_folder, with the distinguishing factor that this operation is reversible. This tells an agent when to select archive_folder instead of a deletion 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?

With no annotations provided, the description carries full burden. It reveals key behavioral traits: archiving removes accounts from lists, stops sync without data loss, is reversible, and restore consumes a plan slot and can fail. This is meaningful behavioral context that the agent cannot infer from the schema or tool name alone.

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

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

Three dense sentences with zero filler. The main purpose is front-loaded, followed by the non-deletion safety trait and the restore slot risk. Every sentence earns its place and is highly scannable.

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

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

Given the tool has no output schema and no annotations, the description covers what the operation does, key side effects, undoability, restore constraints, a failure mode, and a sibling comparison. An agent has enough context 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?

The input schema already provides 100% coverage with descriptions for all three parameters (accounts, archived, platform). The description reinforces the archive/restore distinction but does not add meaning beyond the schema—the schema already explains username/display name/id, true/false semantics, and platform disambiguation.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Archive (or restore)') and a specific resource ('the org's own connected accounts (My Accounts)'). It distinguishes itself from delete_my_accounts by explicitly saying archiving does not delete anything and can be undone. An agent can immediately understand what this tool does and how it differs from its destructive 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?

Provides direct usage guidance: 'prefer it to delete_my_accounts whenever the data might still be wanted.' It also explains when restore behavior applies and warns about a concrete failure mode (LIMIT_REACHED). This is explicit, actionable, and routes the agent to the right 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that creators are notified by push, that assigning an already-assigned post updates rather than duplicates, and that omitted fields retain their current values. It does not mention permissions, error behavior, or whether updates trigger new notifications, but the key side effects are covered.

Agents need to know what a tool does to the 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 deliver the purpose, prerequisite, key side effect, and update behavior with no filler. The most important usage constraint is front-loaded, and every sentence contributes information an agent needs before calling the tool.

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

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

The description covers prerequisites, notifications, and upsert semantics, which is strong for a mutation tool with no annotations. However, there is no output schema and the description does not state what the tool returns on success or failure, which leaves a meaningful gap for an agent trying to confirm the result of the operation.

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

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

Schema description coverage is 100%, so each parameter already has meaningful documentation. The description reinforces the source of post_id and the update semantics, but it does not add significant new parameter-level meaning beyond what the schema already provides. 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 opens with a specific verb and resource: 'Assign a viral post to one or more creators so they reproduce it.' This clearly distinguishes the tool from siblings like get_assignment, list_assignments, and delete_assignment, and the '(Production workflow)' qualifier adds contextual scope.

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

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

It explicitly states the prerequisite that the post must already exist in the library and points to relevant tools for sourcing valid post IDs. It also explains the upsert behavior, which helps agents decide whether this tool is appropriate for already-assigned posts. It does not explicitly mention alternatives like update_assignment, but the usage context is clear.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It correctly signals a privileged write operation through the org-owner/admin constraint, which is genuinely useful context that annotations would otherwise need to provide. It does not disclose duplicate-name behavior, response format, or side effects beyond resource creation, leaving meaningful gaps for a mutating tool.

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

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

Two sentences with zero filler, and the primary action is front-loaded. Every clause — the resource scope and the permission prerequisite — earns its place by adding information an agent needs to call the tool correctly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 create tool with no output schema, this is largely complete: it covers purpose, applicable resources, and an authentication prerequisite. Remaining gaps are minor, such as not mentioning the response contents (e.g., the created category id) or behavior on duplicate names. An agent can invoke it correctly for the common case without further inference.

Complex tools with many parameters or behaviors need more documentation. 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 both name and color already documented, so per the calibration baseline the description does not need to add parameter details. The description does not add meaning to the parameters themselves, but the scope note (watchlist accounts, posts and assets) helps contextualize naming. No parameter documentation gaps exist.

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

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

The description states a specific verb and resource ('Create a category') and adds meaningful scope by noting categories are usable on watchlist accounts, posts and assets. This clarifies what the resource is for and roughly separates it from other taxonomy tools like tags. It does not explicitly name alternative siblings such as update_category or the set_*_category family, so differentiation relies mostly on the resource name.

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

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

No explicit when-to-use or when-not-to-use guidance is given, and no alternative tool is named. The permission constraint ('Only the org owner or an admin can manage categories') implicitly tells an agent not to call this without sufficient privileges, which is actionable. However, the agent must infer when creating a new category is the right step versus assigning an existing one via the sibling set_*_category tools.

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

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

With no annotations, the description carries the burden and does disclose one meaningful behavioral guarantee: 'Folders created here stay writable by the app.' It also explains the linking effect ('creators' videos land in it'), but it does not mention permissions, error/duplicate behavior, or whether the operation has external irreversible effects beyond creation.

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

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

Two sentences, front-loaded with the core action, then the optional linking behavior, then the writability guarantee. No filler or repetition.

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

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

For a low-complexity create operation with complete schema descriptions, the description covers the core invocation context: creation location, optional production-folder link, and post-creation write access. It does not specify the return value or collision/permission failure behavior, but those are secondary given the schema and simple parameter set.

Complex tools with many parameters or behaviors need more documentation. 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 contextual value beyond the schema by explaining the purpose of link_to_folder (so creators' videos land in the folder) and the location options for parent_drive_folder (root or an accessible Drive folder).

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

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

The description uses a specific verb/resource pair ('Create a folder in the organization's connected Google Drive') and states the operational scope ('at the root, or inside an accessible Drive folder'). It distinguishes this from the sibling create_folder by explicitly scoping to the connected Google Drive and adding the optional production-folder linking 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 implies the main use cases: creating a Drive folder at root or under a parent, and optionally linking it to a production folder. It does not explicitly compare against alternative tools such as create_folder or set_drive_folder, nor 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?

With no annotations provided, the description carries full responsibility for behavioral disclosure. It does reveal an important non-obvious behavior: a creator-owned ROOT folder becomes her bucket and drives per-creator routing. However, it does not cover permission requirements, failure behavior, or whether creation is idempotent.

Agents need to know what a tool does to the 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 dense sentence that front-loads the main action and then efficiently explains the optional variants. It does contain slight redundancy between 'optionally owned by a creator' and 'creator-owned,' but overall it is compact and focused.

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

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

For a three-parameter creation tool with no annotations and no output schema, the description covers the essential behavioral nuance around parent and owner semantics. It could mention uniqueness constraints or error conditions, but the core information an agent needs to decide whether to call it 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?

The schema already documents all three parameters with descriptions, so the baseline is met. The description adds extra meaning beyond the schema by explaining that owner_model is only meaningful on a root folder and describing the resulting bucket/routing behavior, which is not 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 uses a specific verb and resource ('Create an assignment folder') and clearly distinguishes this from sibling tools by stating exactly what it creates. It also adds the parent/owner nuances that separate it from generic folder utilities.

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

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

The description gives clear context for when to use the tool, especially the optional parent and owner parameters, but it does not explicitly mention alternatives or when-not-to-use conditions. Unlike more comprehensive descriptions, it relies on the verb 'Create' to imply usage.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. The word 'permanently' clearly communicates that deletion is irreversible, which is the most important behavioral trait for a delete tool. It does not mention cascading side effects, permissions, or return values, but the key destructive characteristic is disclosed.

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

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

Two concise sentences with no filler or unnecessary detail. The primary purpose is front-loaded, and the alternative usage guidance is placed second. 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?

This is a simple one-parameter tool with no output schema. The description covers what the tool does, its irreversibility, and when to use the sibling alternative. It could mention what happens to dependent data or the result format, but those are not essential for an agent to invoke it correctly.

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

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

The schema covers assignment_ids with a clear description, so the description does not need to repeat it. The phrase 'one or more assignments' aligns with minItems: 1 but adds little beyond the schema. No additional details such as id format or source of ids are provided, so this stays at the baseline.

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

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

The description states a specific verb and resource: 'Delete one or more assignments permanently.' It also clarifies that deletion is distinct from update_assignment, which is named explicitly. This leaves no ambiguity about what the tool does.

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

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

It gives explicit guidance on when to prefer the alternative: 'Prefer update_assignment (status refused) when the work should be redone.' This tells an agent the decision boundary between deleting and updating, which is strong usage 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?

With no annotations provided, the description carries the behavioral disclosure burden. It clearly states the non-destructive side effect on accounts, posts, and assets, and it discloses the permission requirement. It does not mention whether deletion is reversible, but for a delete operation 'irreversible' is reasonably implied; overall transparency is strong.

Agents need to know what a tool does to the 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 filler. The core action is front-loaded, and every subsequent detail earns its place by explaining consequences or permissions. This is highly efficient for an agent to parse.

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

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

For a single-parameter tool with no output schema and no annotations, the description is complete enough: it states the action, the dependent-object behavior, and the authorization requirement. Nothing essential to selecting or invoking this tool is missing.

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

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

The schema already documents the only parameter with 100% coverage: 'Category to delete (id or name)'. The tool description adds no additional semantic detail beyond the schema, so the baseline score of 3 is appropriate. There is no gap requiring compensation.

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

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

The description begins with a specific verb and resource: 'Delete a category.' It also clarifies what happens to dependent objects, distinguishing this from destructive deletes like delete_folder or delete_tag. An agent can clearly identify what this tool does and why it differs from sibling category tools.

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

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

The description provides an important usage condition with 'Owner or admin only' and implies the effect on dependent objects, which helps an agent decide to use it. However, it does not explicitly state when to prefer this over update_category, create_category, or set_post_category. The usage guidance is adequate but left mostly implicit.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavior. It reveals that deletion is permanent, that subfolders are also deleted, and that assignments inside are kept but lose their folder—critical behavioral consequences beyond what the schema shows.

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

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

Two sentences with no filler. The most important information—permanence—is front-loaded, and the irreversible cascade effects are packaged efficiently in one parenthetical clause.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 single-folder deletion tool, the description is complete: it covers the action, permanence, cascading subfolder behavior, effect on contained assignments, and a safer alternative. Nothing essential 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?

The single parameter 'folder' is already fully documented in the schema with 'id, name or full path'. The description adds only that it is an assignment folder, so it provides minimal extra semantic value beyond 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 states a specific action ('Delete an assignment folder PERMANENTLY') and resource, and even distinguishes itself from the reversible sibling by naming 'update_folder with archive'. An agent can understand exactly what this tool does and how it differs from nearby alternatives.

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

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

The description explicitly says to prefer 'update_folder with archive' because it is reversible, giving clear guidance on when not to use this destructive alternative. It also notes the irreversible nature of the delete, which helps the agent choose appropriately.

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

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

With no annotations, the description carries the full behavioral burden, and it does this well. It discloses irreversibility, recursive subtree deletion, and the non-obvious side effect that assignments are kept but lose their folder. This is exactly the kind of transparent side-effect disclosure needed for a destructive tool.

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

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

The description is two sentences with no wasted words. The core action and critical side effects are front-loaded, and the reversible alternative is placed at the end as a practical recommendation.

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

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

For a simple one-parameter destructive tool with no output schema and no annotations, this description is complete. It covers the purpose, the main side effects, the irreversibility, and the safer alternative, leaving no critical gap for an agent deciding whether and how to call it.

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

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

The schema already fully documents the folders parameter with 100% coverage, including accepted forms (id, name, or full path). The description adds the 'several in one call' context but no additional parameter-level meaning, 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?

The description names a specific action (Delete), a specific resource (assignment folders), and the key scope (SEVERAL in ONE call, PERMANENTLY). It also distinguishes itself from reversible archive_folder and implicitly from the singular delete_folder sibling by emphasizing bulk, irreversible deletion.

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

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

The description gives an explicit alternative: 'Prefer archive_folder, which is reversible,' and the permanence of this tool clarifies when each should be chosen. It doesn't explicitly enumerate all when-not scenarios or mention the singular delete_folder sibling, but the core usage context is clear.

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

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

With no annotations present, the description carries the full disclosure burden and meets it: it warns 'PERMANENTLY' and 'NOT reversible,' enumerates the complete destructive scope ('its posts, its stats, its tags and its scheduled posts, and the official Instagram/TikTok connection is cut'), and clarifies this is not equivalent to a simple disconnect. No annotation contradiction exists, and no severe behavioral trait is left undisclosed.

Agents need to know what a tool does to the 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, roughly 70 words, with the core action front-loaded and every sentence earning its place: action and scope, destructive detail, then irreversibility warning with alternative and typical use case. There is no fluff and no 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 destructive batch tool with no annotations and no output schema, the description covers everything needed for correct invocation: purpose, exact destructive scope, irreversibility, the alternative path, and a representative use case, while the 100%-coverage schema handles parameter semantics including the confirm dry-run behavior. The only omissions — partial-failure behavior and response shape — are minor for a call that is already gated by the confirm flag.

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

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

Schema description coverage is 100%, so the schema already documents accounts (accepted identifiers), confirm (dry-run vs. actual delete), and platform (disambiguation), earning the baseline 3. The description adds only marginal parameter-level meaning — 'one or SEVERAL' reinforces the accounts array's multi-entry capability, and the burner-account use case hints at which accounts are appropriate targets — but provides no syntax or format details beyond the schema.

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

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

The description opens with a specific verb and resource — 'Delete one or SEVERAL of the org's own connected accounts (My Accounts) PERMANENTLY, in one call' — and precisely defines scope (multiple accounts in a single call). It explicitly distinguishes itself from archive_my_accounts with 'NOT the same as disconnecting,' so an agent can tell the tools apart without inspecting 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?

The description names the alternative tool explicitly: 'use archive_my_accounts instead to take accounts out of the views while keeping their data.' It also provides a concrete trigger scenario — 'cleaning up burner accounts that got banned or checkpointed and will never come back' — giving the agent both a when-to-use and a when-not-to-use rule.

Agents often have multiple tools that could apply. Explicit usage 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 no annotations provided, the description carries the full burden of behavioral disclosure. It clearly warns that this is a global destructive action affecting every post, every asset, and the global registry. It doesn't mention irreversibility or permission requirements, but the dramatic scope is the most important behavioral trait and is stated explicitly.

Agents need to know what a tool does to the 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 filler. The global destructive scope is front-loaded, and the alternative tools are named in a clear second sentence. Every word earns its place.

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

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

This is a simple one-parameter tool with no output schema and no nested objects. The description fully explains what the tool does, the full side effects, and when to choose a different tool. Nothing an agent needs to safely invoke 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?

The schema already covers the single 'tag' parameter fully with a description ('Tag to delete (as shown by list_tags)'), so the baseline is 3. The tool description itself does not add further parameter-level detail, but the schema is sufficient for correct invocation.

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

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

The description names a specific verb and resource ('Delete a tag') and goes beyond a simple statement by specifying the exact scope: 'removes it from every post and asset of the organization and from the global registry.' It clearly distinguishes itself from sibling tools like tag_posts and update_asset, which handle individual untagging.

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

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

The description explicitly tells the agent when to use this tool vs. alternatives: 'Use tag_posts / update_asset with remove_tags to untag individual items instead.' This directly addresses the main selection ambiguity and leaves no room for misinterpretation.

Agents often have multiple tools that could apply. Explicit usage 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 no annotations present, the description carries the full burden and reveals non-obvious behaviors: copied assignments get a fresh 'pending' status and Drive links are not copied. It could go further by mentioning permissions, reversibility, or what the returned output looks like, but the key side effects 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?

Three compact sentences with no filler: the first states the core behavior, the second explains the primary use case, and the third gives the key caveat with an alternative. Every sentence earns its place and the most important information is front-loaded.

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

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

For a moderately complex tool with five parameters and no output schema, the description covers the main behavior, the special owner_model scenario, and the Drive-link limitation. Minor gaps such as return value, permissions, or error behavior are not critical for an agent to invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3 because all five parameters already have meaningful descriptions. The description adds context about the owner_model cloning use case and assignment status, but it does not need to define parameters again. This is adequate.

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

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

The description uses a specific verb and resource ('Duplicate a folder') and spells out the two core outcomes: recreating the subfolder tree and copying assignments. This clearly differentiates it from sibling tools like create_folder, move_folders, or archive_folder even without seeing 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?

The description gives a concrete scenario for owner_model ('clone a template folder for a NEW creator') and explicitly names set_drive_folder as the alternative when Drive links are needed. It does not explicitly contrast with create_folder for simple folder creation, but the provided guidance is sufficient for most routing decisions.

Agents often have multiple tools that could apply. Explicit usage 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 no annotations, the description carries the behavioral disclosure burden. It does this well by explaining the two URL types: download_url forces a download with a clean filename and expires in 24h, while file_url is permanent and public. It stops short of covering auth requirements or exact response structure, but provides meaningful behavior beyond the schema.

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

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

The description is two compact sentences: the first states the core purpose and scope, the second adds URL behavior details. Every clause earns its place, and the most important information is front-loaded.

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

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

For a low-complexity one-parameter tool with no output schema, the description covers the essential return semantics by naming download_url and file_url and explaining their differences. It leaves minor gaps such as exact response field naming for the thumbnail, but the description 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?

The schema already covers the single parameter fully with a clear description ('Asset (id from search_assets, or exact name)'), so the baseline is 3. The tool description adds only the context that the asset belongs to the library, which is marginal but not necessary for invoking the tool.

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

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

The description names a specific action ('Get downloadable URLs') and a specific resource ('an asset of the library'), and clarifies the output includes both the original file and its thumbnail. This makes it clearly distinguishable from sibling download-URL tools that target posts or account posts.

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

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

It provides useful context for when the tool is relevant ('to save it or send it to another service like a Drive'), but it does not explicitly compare it to sibling download-URL tools or state when not to use it. Given the several download-URL siblings, explicit routing would improve this dimension.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It clearly states this is a read operation and lists the specific payload elements the agent will receive, including the notable detail that submitted videos are returned as URLs. It doesn't mention error behavior or auth, but for a simple getter this is adequate.

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

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

A single, information-dense sentence with the core action front-loaded and the details cleanly enumerated after a colon. There is no filler or redundancy.

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

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

Given a single parameter and no output schema, the description does a good job of communicating what the agent will receive. It doesn't cover error cases or response envelope, but that is a minor gap for a straightforward fetch-by-ID tool.

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

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

The schema already fully describes assignment_id, including its provenance ('from list_assignments'). The description adds no new parameter semantics beyond identifying the target as an assignment, so with 100% schema coverage 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 ('Get'), a specific resource ('one assignment'), and enumerates the exact details returned (notes, reply thread, due date, video URLs). This clearly distinguishes it from list_assignments (which lists) and update/delete_assignment (which mutate).

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

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

The phrase 'one assignment' plus the single required assignment_id makes it clear this is for fetching details of a specific assignment, likely after calling list_assignments. It doesn't explicitly name alternatives or exclusions, but the context is unambiguous.

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

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

There are no annotations, so the description carries the behavioral disclosure burden. 'Get' clearly signals a read-only operation, and the listed stat categories indicate the kind of aggregated dashboard response to expect. It does not go into return format details, but for a zero-parameter read tool this is a minor gap.

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

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

The description is a single, well-structured sentence that front-loads the core purpose and then uses a colon-separated list to enumerate the returned stat categories. Every word contributes meaning; 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?

Given the tool has no parameters, no output schema, and no annotations, the description supplies the essential return-value categories and organizational scope. It could slightly improve by stating the response shape, but the provided list of dashboard stat areas is sufficient for an agent to call and interpret the result.

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

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

The tool has zero parameters and 100% schema description coverage, so the schema fully captures the input surface. Per the rubric, a zero-parameter tool gets a baseline of 4; the description appropriately adds no unnecessary parameter 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 clear verb and resource: 'Get the organization's dashboard stats' and enumerates the included components. This distinguishes it from the sibling get_my_account_stats by explicitly focusing on organization-level rather than account-level data.

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

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

The description provides a clear context for use—retrieving org-wide dashboard metrics such as watchlist size, viral post counts, analyses, and recent activity. It does not explicitly name alternatives or state when not to use this tool, but the organization scope makes the semantic boundary to sibling tools reasonably clear.

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

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

With no annotations, the description carries the behavioral disclosure burden. It states this is a status check, implying read-only behavior, and importantly discloses that the MCP cannot initiate the Google consent screen—only a manager can from the app. This prevents an agent from attempting to connect directly. It does not explicitly say 'read-only' or 'no side effects,' but 'Status of' is reasonably clear.

Agents need to know what a tool does to the 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 and front-loads the core purpose. The second sentence adds valuable context about how the connection is established and what the MCP can do once connected, though it is slightly more verbose than a simple status check requires. Overall, 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?

For a zero-parameter, no-output-schema status tool, the description is complete: it explains the tool's purpose, the external setup dependency, and the capabilities enabled by the connection. An agent has enough information to decide when to call this tool and what to tell the user if it fails.

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

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

The tool has zero parameters, and schema description coverage is 100%, so there is nothing for the description to add about parameter semantics. The baseline for a zero-parameter tool is 4, and the description adds relevant context about what the status represents.

Input schemas describe structure but not intent. Descriptions should explain 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 this as a status-check tool for the organization's Google Drive connection, with a specific verb ('Status of') and resource. It distinguishes itself from siblings like list_drive_folders or create_drive_folder by focusing on the connection itself and the prerequisite it represents.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 this matters: before using Drive folder operations, the agent should know whether the connection exists. It also explains that setup can only be done by a manager via the app, which helps route the user appropriately. It does not explicitly say 'use this before list_drive_folders,' but the implication 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?

With no annotations provided, the description carries full responsibility for behavioral disclosure. It excels here: explains that Instagram URLs expire in a few hours, are resolved live from the official API, and are directly fetchable; and that TikTok URLs require session cookies and typically cannot be fetched by external services. These are material behavioral traits that an agent needs to know.

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

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

The first sentence states the core purpose and scope; the second sentence delivers the critical platform-specific caveats. Every word earns its place, no filler or repetition, and the key differentiator ('OWN posts') 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?

Given the tool's simple single-parameter signature and no output schema, the description covers the essential operational context: scope, platform differences, expiration, and cookie requirements. It doesn't spell out the exact response format, but that is arguably optional for a tool whose purpose is to return a URL (and possibly cookies). The main caveat is that for TikTok, it implies the response includes session cookies but doesn't detail how they are returned.

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

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

The schema has 100% coverage for the single parameter post_id, with its own description ('UUID, the id field from list_my_account_posts'). The tool description adds context about 'OWN posts (My Accounts)' but doesn't elaborate on post_id beyond what the schema already states. At 100% coverage, the baseline of 3 is appropriate.

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

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

The description names a specific verb ('Get') and resource ('downloadable URL for the video of one of the org's OWN posts (My Accounts)'), directly distinguishing it from sibling tools like get_post_download_url by scoping to 'My Accounts'. The purpose is immediately clear and unambiguous.

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

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

The description provides clear context for when to use the tool: for an org's own posts, not external ones. It also gives actionable guidance like 'use it right away' for Instagram and warns that TikTok URLs are unsuitable for external services. However, it never explicitly names an alternative tool for other post types, leaving some inference 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?

There are no annotations, so the description carries the burden of disclosing behavior. It makes the read-only nature clear via 'Get' and transparently enumerates the data returned. It does not mention edge cases like empty stats or rate limits, but for a read operation on an internal account these are not critical omissions.

Agents need to know what a tool does to the 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, dense sentence with no filler. It front-loads the core action and resource, then efficiently lists the key output categories in a parenthetical-colon structure.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 two parameters and complete schema documentation, the description covers the target resource, the output categories, and the scope. The main gap is the absence of an output schema and any explanation of 'breakthrough count,' but the input side is fully specified and the tool's behavior is sufficiently clear.

Complex tools with many parameters or behaviors need more documentation. 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 parameters 'account' and 'platform' are already well-documented. The description adds context about the returned metrics, but it does not add new meaning to the parameters themselves, matching the baseline for full schema coverage.

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

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

The description uses a specific verb ('Get') and a clear resource ('growth stats of one of the org's own connected accounts (My Accounts)'). It lists concrete outputs—followers/views history snapshots, breakthrough count, and top posts by views—which distinguishes it from other account-related sibling tools like list_my_accounts or summarize_my_accounts.

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

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

The description clearly states the context: it applies to the org's own connected My Accounts, not to third-party or viral accounts. It does not explicitly name alternative tools or provide when-not-to-use guidance, but the scope is specific enough that an agent can infer when this tool is appropriate.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It discloses that AI analysis is included 'when available' and enumerates the analysis components, but it does not describe the full return structure, error behavior, or any side effects. This is acceptable for a simple read operation but leaves some behavior unspecified.

Agents need to know what a tool does to the 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 filler. It front-loads the main purpose and immediately follows with actionable parameter guidance.

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

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

For a simple one-parameter getter with no output schema, the description provides the essential context: what is returned, what the AI analysis contains, and where the id comes from. It does not detail the full response fields or missing-analysis behavior beyond 'when available,' but this is a minor gap for the tool's simplicity.

Complex tools with many parameters or behaviors need more documentation. 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 post_id as a UUID or Instagram shortcode, so coverage is complete. The description adds value by stating that the id should come from list_viral_posts or list_analyzed_posts, giving the agent provenance beyond the schema.

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

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

The description uses a specific verb and resource: 'Get the full detail of one viral post.' It also names the unique content of the tool, the AI analysis with hook, structure, virality reasoning, and replication guide, which clearly distinguishes it from siblings like get_post_preview and get_post_download_url.

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

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

The description explicitly tells the agent to pass the post id returned by list_viral_posts or list_analyzed_posts, which provides a clear source for the parameter and context for when to call this tool. It implies the alternative get_post_preview for previews, though it does not explicitly name 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?

No annotations are present, so the description carries the full burden. It discloses non-obvious behaviors: permanent copies exist only for AI-analyzed posts, URLs can expire, and TikTok CDN links often refuse non-browser downloads. It does not cover auth or rate limits, but the key behavioral traits are well explained.

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

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

Two sentences with no wasted words. The purpose is front-loaded and the critical expiration/TikTok caveats are efficiently packed into the second sentence. Every clause earns its place.

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

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

With one simple parameter, no output schema, and no annotations, the description covers the returned URL, thumbnail inclusion, and important edge cases. It lacks explicit mention of response format or error behavior, but that is a minor gap given the tool's simplicity.

Complex tools with many parameters or behaviors need more documentation. 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 single post_id parameter is already fully documented in the schema. The description adds no additional parameter-level meaning, so baseline 3 is appropriate.

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

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

The description states a specific action and resource: 'Get a downloadable URL for a library post's video file (plus its thumbnail)'. It also distinguishes this from related siblings like get_asset_download_url and get_my_account_post_download_url by focusing on library posts and mentioning the permanent_copy vs CDN source 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?

It provides clear contextual guidance: saving the file or sending it to another service. It also gives important decision-relevant caveats about permanent vs expiring URLs and TikTok CDN behavior. However, it does not explicitly name sibling alternatives or state when not to use this tool.

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

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

With no annotations provided, the description carries the full burden. It discloses the output behavior (returns image inline plus video URL when available) and the scope limitation (only viral/assignment posts), which adds meaningful behavioral context. It does not mention permissions or failure modes, but for a read-style tool this is a reasonable level of transparency.

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

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

The description is two sentences with no filler. It front-loads the core purpose, then gives scope and return details. Every sentence contributes useful 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?

This is a simple one-parameter tool with no output schema. The description covers what it returns, the input source, and the scope. An agent has enough information to select and invoke it correctly.

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

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

Schema coverage is 100%, so the schema already documents post_id clearly as a UUID from list_viral_posts, list_analyzed_posts or an assignment. The description adds no new parameter-level meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description names a specific verb ('Get'), a clear resource ('visual preview (thumbnail image)'), and the user-facing purpose ('so the user can SEE it in the conversation'). It distinguishes itself from sibling tools like get_post_analysis and get_post_download_url by clarifying it returns a visual image, not analysis or a downloadable file.

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

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

It states the applicable context: this works for the org's viral posts and posts referenced by an assignment. It does not explicitly call out alternatives or when not to use it, but it gives enough context for an agent to recognize the intended use case.

Agents often have multiple tools that could apply. Explicit usage 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 no annotations provided, the description carries the burden of behavioral disclosure. It conveys a read-only, snapshot-like operation ('current snapshot') and notes the optional niche filter, but it does not mention return shape, pagination, or any operational caveats. This is adequate but leaves some behavioral details to inference.

Agents need to know what a tool does to the 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, tightly constructed sentence. It front-loads the core action and resource, then adds the optional filtering detail. There is no redundant or extraneous wording.

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

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

This is a simple, low-complexity retrieval tool with two self-explanatory parameters and no output schema. The description fully explains what the tool does and how filtering works, which is enough for an agent to call it correctly. Minor gaps, such as explicit return format details, are not critical here.

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

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

Schema description coverage is 100%, so the schema already documents both 'limit' and 'niche' clearly. The description adds no extra parameter semantics beyond what the schema provides, which is acceptable given the high coverage and low parameter count. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Get') and resource ('trending sounds'), and adds clarifying context by defining them as 'music rising on Instagram Reels.' This clearly distinguishes the tool from sibling tools like list_viral_posts or search_assets, and communicates the exact purpose without ambiguity.

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

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

The description makes the tool's use context clear: it retrieves the current trending sounds and can be scoped by niche. It doesn't explicitly state when not to use it or name alternatives, but no sibling tool covers trending sounds, so the guidance is sufficient for selection.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It does reveal ordering and filtering behavior, and instructs that the url must be included when presenting posts. However, it does not state whether the operation is read-only, describe limits or errors, or disclose any additional return behavior.

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

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

Two sentences, both purposeful and front-loaded. The first sentence defines the tool's core behavior, and the second adds a practical presentation requirement. There is no redundant or filler content.

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

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

For a simple list tool with two self-documenting pagination parameters, the description provides the essential filter, ordering, and display guidance. It lacks an explicit statement of the full return shape, but given the absence of an output schema, mentioning the url field and thumbnail option covers the key use case.

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

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

Schema description coverage is 100%, with the schema already documenting limit and offset, including their defaults and bounds. The tool description adds no additional parameter-level meaning, 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 states a specific verb ('List') and resource ('posts that already have a completed AI analysis'), and adds the ordering behavior ('newest first'). This clearly distinguishes it from sibling tools like list_my_account_posts or list_viral_posts without relying on the tool name 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?

The description gives clear context that this tool is for retrieving analyzed posts and provides a presentation rule for the user-facing response. It references get_post_preview for inline thumbnails, but it does not explicitly contrast this tool with sibling list tools such as list_my_account_posts or list_viral_posts.

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

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

There are no annotations, so the description carries the behavioral burden. It usefully discloses the status vocabulary and gives a specific presentation requirement ('include the post_url link'), which adds context beyond the schema. However, it does not mention reading behavior, potential side effects, permissions, or default/return behaviors beyond the statuses.

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

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

The description is concise and front-loaded: it defines the resource, explains the status flow, and adds the key presentation instruction. Every sentence contributes useful information and there is no redundancy.

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

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

For a simple list tool with all-optional parameters and no output schema, the description covers the core purpose, the status domain, and the key output presentation rule. It does not detail the full return shape, but enough context is provided for an agent to call the tool correctly and interpret the result in most 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 100%, and each parameter already has a clear description in the schema. The tool description adds context about statuses and the relevance of post_url, but does not meaningfully enhance the semantics of limit, model, or status 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 verb ('List') and a specific resource ('the organization's content assignments'), and clarifies what those are with the parenthetical 'viral posts assigned to creators to reproduce'. It also distinguishes this from single-item tools like get_assignment by focusing on listing multiple assignments with production 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?

The tool's purpose is clear and it is easy to infer it should be used when retrieving multiple assignments rather than a single one, but the description never explicitly states when to use it versus sibling tools like get_assignment or list_viral_posts. No exclusions or alternative routing are provided.

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

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

No annotations exist, so the description carries the full disclosure burden. It does add useful behavioral context — that a single category can be reused across watchlist accounts, library posts, and assets — which prevents an agent from assuming categories are entity-scoped. However, it omits ordering, pagination, and response shape, which are unstated since no output schema exists.

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

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

Two short sentences, both earning their place: the first states the operation, the second conveys the one non-obvious domain fact. The verb and resource are front-loaded with zero filler.

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

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

For a zero-parameter, no-output-schema listing tool, the description captures the essential scope ('organization's categories') and the key cross-entity sharing semantic. Everything needed to call it correctly is present; missing details like response fields or ordering are minor gaps for such a simple read operation.

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

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

The tool has zero parameters, and the schema is trivially 100% covered. With no parameters to explain, the baseline of 4 applies; the description correctly avoids inventing param details that don't exist.

Input schemas describe structure but not intent. Descriptions should explain 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: 'List the organization's categories.' The second sentence adds meaningful scope by explaining categories are shared across watchlist accounts, library posts, and assets. It clearly differentiates from account-scoped tools like list_my_account_categories through the 'organization's' qualifier, though it never names the sibling explicitly.

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

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

The intended use is implied: this returns org-wide categories, in contrast to the account-scoped list_my_account_categories sibling. However, the description provides no explicit when-to-use or when-not-to-use guidance, and never names the alternative tool an agent should pick for account-specific categories.

Agents often have multiple tools that could apply. Explicit usage 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 no annotations, the description carries the behavioral disclosure burden. It discloses a key constraint: only folders within drive.file scope, specifically picked or created via create_drive_folder, are listed. This goes beyond a bare 'list' statement and helps set expectations about the returned set.

Agents need to know what a tool does to the 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 dense sentence that front-loads the action and resource, then explains the scope constraint and the purpose of the returned ids. Every clause adds useful information with no filler.

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

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

For a no-parameter list tool with no output schema, the description covers what is returned and how to use it. It could be slightly more explicit about the exact response shape, but the essential selection and invocation 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?

The tool has no parameters, so there is no parameter documentation burden. The 100% schema coverage and empty properties make this trivially complete.

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

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

The description uses a specific verb and resource: 'List the Google Drive folders this app can write into.' It also distinguishes itself from generic folder tools by scoping to drive.file write access and by explicitly pointing to set_drive_folder as the consumer of the returned ids.

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

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

It clearly states the intended use case: retrieve writable Drive folders and use their ids with set_drive_folder. It gives enough context to know when this tool is relevant, 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?

With no annotations, the description carries the behavioral burden itself. It discloses that archived folders are excluded by default (via the parameter default), that results are returned as a tree, and that per-creator root folders drive automatic routing—useful context beyond a mere 'list folders'. It doesn't mention whether this is a light read operation or any authorization needed, but for a list operation the disclosure is reasonably complete.

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

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

Two sentences with no filler: the first sentence states the operation, output fields, and the tree format; the second justifies the folder structure's importance. Everything earns its place, and the key action is front-loaded.

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

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

For a one-parameter list tool with a simple boolean, the description is complete. It names the output fields, explains the tree shape, gives the domain context (Production workflow, automatic routing), and the schema handles the parameter. No output schema is present, but the listed fields cover what an agent needs to 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 the schema already documents include_archived. The description adds context around what 'archived' means via the archived flag, and the tree/full-path framing implies the folder hierarchy, which helps interpret the parameter's role. Above baseline because it explains the returned structure that the parameter affects, but it doesn't add syntax details for the boolean itself.

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

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

The description uses a specific verb ('List'), names the resource ('the organization's assignment folders'), and states the output shape ('as a tree (id, full path, creator owner, archived flag)'). It also clarifies the folder role in the Production workflow and per-creator routing, distinguishing it from sibling tools like list_drive_folders or list_categories.

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

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

The description clearly implies this is a read/listing operation for assignment folders and hints at the Production workflow context, so an agent can infer when to call it. It doesn't explicitly name alternatives or state when-not-to-use, but the sibling list is broad enough that the tree structure and folder-specific language route the agent adequately.

Agents often have multiple tools that could apply. Explicit usage 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 no annotations provided, the description carries the behavioral disclosure burden. It states what the tool returns (model IDs, names, or emails), signals a filtering behavior ('who can receive content assignments'), and implies a read-only listing operation. It does not mention pagination, ordering, or response shape, but for a zero-parameter list tool this is adequate.

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

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

The description is two sentences with no filler. The first sentence states the core purpose, and the second provides actionable guidance. 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?

This is a low-complexity tool with no parameters and no output schema, and the description still explains what is returned and how to use the result. An agent has enough information to call the tool and correctly interpret its output without further research.

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

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

The tool has zero parameters and the schema is fully described at 100% coverage, so there is nothing for the description to add about parameters. Per the rubric, a zero-parameter tool receives a baseline of 4.

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

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

The description names a specific verb ('List') and a specific resource ('creators/models of the organization who can receive content assignments'), which clearly distinguishes this tool from siblings like list_assignments or list_categories. The clarifying parenthetical 'models' resolves the otherwise ambiguous tool name.

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

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

The description provides clear context for when to use the tool: when you need creators/models to receive content assignments. It also ties the result to a downstream action, create_assignment. It does not explicitly mention alternatives or exclusions, but the use case is sufficiently clear.

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

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

No annotations are provided, so the description carries the behavioral transparency burden. The verb 'List' clearly signals a read-only operation, and the description scopes exactly which category set is returned. It does not mention pagination or auth expectations, but for a simple parameterless list tool this is a minor gap.

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

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

The description is two sentences with no filler. The primary action and scope are front-loaded, and the differentiation from the sibling tool is delivered in a single concise clause.

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

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

For a zero-parameter tool with no output schema, the description fully defines the scope and distinguishes it from the most relevant sibling. Nothing essential is missing for a model to select and 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 input schema has zero parameters and schema description coverage is 100%, so there are no parameter semantics to clarify. The description still adds useful context by specifying that the categories are for the org's own connected accounts, which is sufficient for an empty schema.

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

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

The description clearly states a specific verb and resource: it lists categories for the org's own connected accounts (My Accounts). It also explicitly distinguishes itself from list_categories, so a model can immediately tell which tool returns which category namespace.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 names the sibling list_categories and explains the key difference: list_categories returns shared categories for watchlist accounts, library posts, and assets, while this tool returns categories for My Accounts. This gives the agent an explicit selection rule.

Agents often have multiple tools that could apply. Explicit usage 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 no annotations provided, the description carries the full behavioral disclosure burden and does meaningful work: it states the default ordering ('newest first by default'), defines 'breakthrough posts' via 'the org's virality threshold,' and imposes a presentation rule ('always include each post's permalink'). It does not disclose return shape, permissions, or read-only status, but for a list operation the stated behaviors are the most decision-relevant ones.

Agents need to know what a tool does to the 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 earning its place: purpose plus default order, viral_only semantics, and the permalink presentation requirement. The most identifying fact is front-loaded, and nothing repeats what the schema already states. No fluff.

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

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

The schema fully documents all 8 parameters, and the description supplies the conceptual glue (My Accounts, breakthrough threshold) needed to use filters meaningfully. But with no annotations and no output schema, the description never describes the return structure beyond the permalink requirement, and it does not address pagination behavior or confirm the operation is read-only — notable gaps for a tool with this many options.

Complex tools with many parameters or behaviors need more documentation. 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 8 parameters are already documented in the schema and the baseline is 3. The description adds a small increment by explaining the 'virality threshold' concept behind viral_only and the 'viral' sort option, but it does not compensate for anything the schema omits.

Input schemas describe structure but not intent. Descriptions should explain 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 — 'List the posts published by the org's own connected accounts (My Accounts)' — and the parenthetical defines the domain term. This scope cleanly distinguishes it from siblings like list_analyzed_posts, list_viral_posts, and list_my_accounts. The viral_only explanation further differentiates it from a generic 'list my posts' reading.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 scope statement ('org's own connected accounts') gives implied context for when the tool applies, and the viral_only sentence explains a filtering use case. However, the description never names alternatives or states when not to use this tool — for instance, when list_analyzed_posts or list_viral_posts would be more appropriate — so selection among the dense list_* sibling set is left to inference.

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

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

There are no annotations, so the description carries the burden. It adds useful context: the data source (official APIs) and the returned fields (followers, average views, connection health, category, tags). However, it does not disclose pagination, ordering, output format, or whether the call has side effects beyond 'List', leaving some behavioral ambiguity.

Agents need to know what a tool does to the 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: two sentences, no wasted words. It front-loads the core purpose and scope, then effectively removes ambiguity by contrasting with the watchlist. Every sentence earns its place.

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

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

For a list tool with no output schema, the description communicates its returned fields and scope, which is helpful. It could be more complete by mentioning pagination or default behavior for archived accounts, but the schema already covers the archived default. Overall it is sufficiently complete for an agent to invoke correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds some context about the 'My Accounts' concept and distinguishes from watchlist, but it does not add parameter-level semantics beyond what the schema already documents for tags, category, platform, and include_archived.

Input schemas describe structure but not intent. Descriptions should explain 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 ('the organization's OWN connected accounts (My Accounts)') and clarifies the exact scope: Instagram/TikTok accounts connected via official APIs. It explicitly distinguishes this tool from the watchlist, preventing confusion with a likely sibling tool at a glance.

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

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

The description clearly establishes when to use this tool: for the org's own posting accounts, not for competitors/inspiration. It names the exclusion (watchlist), but does not explicitly name the alternative sibling tool (e.g., list_watchlist_accounts), so the guidance is clear but not fully explicit.

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

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

No annotations are provided, but the description clearly marks the operation as read-only via 'List' and adds useful behavioral context about scope (org's connected accounts) and cardinality (an account can carry several tags). It does not detail output format or pagination, but for a zero-parameter list operation the core behavior is transparent.

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

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

Two compact sentences with no filler. The primary purpose is front-loaded, and the sibling differentiation is placed immediately after without excess explanation.

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

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

For a zero-parameter, read-only list tool, the description is largely complete: it defines scope, differentiates from the nearest sibling, and notes an important relationship. A minor gap is the lack of explicit return-shape information, but the simplicity of the operation makes this non-critical.

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

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

The tool has zero parameters, so the description has no parameter burden. The baseline of 4 applies, and the description adds no unnecessary parameter-level 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 names a specific verb ('List') and resource ('tags available on the org's own connected accounts'), and immediately distinguishes itself from list_tags. This makes the tool's purpose unambiguous and differentiates it from the most 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?

The description explicitly says 'Separate list from list_tags' and clarifies that list_tags applies to library posts and assets. This gives the agent a clear decision rule for when to use this tool versus the 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?

With no annotations provided, the description carries the behavioral disclosure burden. It makes clear this is a read-only listing operation and defines the content as internal team notes. It does not mention ordering, pagination, permission requirements, or behavior for invalid post IDs, though the verb 'List' safely implies non-mutating behavior.

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

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

The description is a single sentence that states the action, the target resource, and a clarifying parenthetical about what the notes are. There is no filler or redundant information.

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

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

For a simple one-parameter read tool, the description plus schema cover how to invoke it. However, there is no output schema and the description does not describe the shape of the returned note thread, pagination, or edge cases, leaving some ambiguity for an agent.

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

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

The sole parameter, post_id, already has complete schema coverage, including its UUID type and provenance from list_viral_posts / list_analyzed_posts. The tool description adds no further parameter-level meaning, so the baseline of 3 applies.

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

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

The description clearly states a specific verb ('List') and resource ('team's note thread on a post'), and clarifies that these are internal notes exchanged between team members. This distinguishes it well from related tools like add_post_note.

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

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

The description implies its use case: retrieve the internal note thread for a given post. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention exclusions or when not to use it.

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

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

With no annotations, the description carries the transparency burden and discloses useful behavioral details beyond the name: the union/deduping scope and normalization to lowercase with hyphens. It does not mention response shape or ordering, but those are less critical for a zero-parameter read-only listing.

Agents need to know what a tool does to the 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 states the primary action and scope, and the second adds a precise normalization rule. There is no filler or repetition.

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

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

For a zero-parameter tool with no annotations and no output schema, the description gives everything an agent needs to select it and understand what it returns: the full organizational scope and the normalized tag format. Nothing essential 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?

There are zero parameters and the empty schema already covers 100% of the parameter surface, so the baseline is 4. The description correctly avoids inventing parameter details and instead explains the semantics of the returned tag values.

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

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

The description starts with a specific verb and resource: 'List all the organization's tags,' so an agent immediately knows the operation and object. The parenthetical defining the union of the global tag registry and every custom tag on posts and assets adds precision and differentiates it from narrower tag tools like list_my_account_tags.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 this tool is appropriate: it returns the organization-wide tag set rather than a per-account or per-post subset. It does not explicitly name sibling alternatives or give exclusion criteria, so it stops short of the strongest 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?

No annotations are provided, so the description carries burden. It discloses useful behavior: results are limited to viral watchlist posts, meaning is defined, and default sort is recency. But it does not explicitly state that this is a read-only operation or describe any side-effect or data-return characteristics beyond the reminder to include `url`.

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

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

The description is three sentences and densely packed with relevant operational information. It leads with the core purpose and follows with actionable presentation guidance. No word is wasted, though the workflow directives might belong in sibling tool descriptions rather than this one.

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

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

For a list operation with no output schema, the description gives enough context to call it correctly: scope, definition of viral, default order, and the need to expose `uurl`. It could be more complete by stating the return shape (e.g., an array of post objects), but it is adequate for the tool's simplicity.

Complex tools with many parameters or behaviors need more documentation. 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 input schem already documents sort, limit, offset, and favorites_only with default sand meanings. The description only repeats the default sorting behavior, adding no new param semantic 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?

The description clearly states the tool lists viral posts on the user's watchlist and defines viral as Instagram Reels and TikTok videos that beat the account's baseline. This specific verb-resource pair distinguishes it from sibling listing tools and leaves little ambiguity about what it returns.

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

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

The description gives operational guidance: include the `url` when presenting posts, use get_post_preview for thumbnails, and use get_post_analysis for AI breakdowns. However, it does not explicitly say when to choose this tool over close siblings like list_analyzed_posts or list_my_account_posts, or when not to use it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains what the returned data includes but does not explicitly state that this is a read-only operation, whether platform filtering defaults to all, or how results are ordered or paginated. The verb 'List' implies read-only, and the return fields are useful, but side-effect and default behavior are underexplained.

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

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

A single, front-loaded sentence states the action, the resource, and the relevant output fields with zero wasted words. Every element 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 low-complexity read tool with one optional parameter and no output schema, the description covers the subject matter and key returned fields. It could be slightly more complete by noting the platform default or the read-only nature, but nothing critical is missing for basic invocation.

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

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

Schema description coverage is 100%: the only parameter, platform, has an enum, a default of 'all', and a clear description. The tool description adds no additional parameter meaning, but since the schema fully documents it, baseline 3 is appropriate.

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

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

Description begins with a specific verb 'List' and names the exact resource: Instagram and TikTok accounts tracked in the user's watchlist. It also states the two key output fields (follower counts, last post date), which distinguishes it from add_watchlist_account, remove_watchlist_account, and the various list_my_accounts 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?

The intended use is implied by 'watchlist' and by naming the platforms, but the description does not explicitly state when to choose this over list_my_accounts or list_my_account_stats, nor does it mention any exclusions. An agent can infer the use case, but guidance is not made 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?

With no annotations, the description carries the behavioral disclosure burden. It clearly conveys the move/remove semantics, which is useful, but it does not mention permissions, reversibility, or what happens if the destination folder does not exist.

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

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

A single sentence that is front-loaded with the main action and includes the key removal case. There is no wasted wording or redundant detail.

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

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

For a simple two-parameter mutation with a rich schema, the description plus schema are sufficient to understand the core operation. It is slightly incomplete only in lacking usage guidance and potential side-effect caveats, but these are not critical given the tool's low complexity.

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

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

Schema coverage is 100%, so the schema already fully documents both parameters. The description's mention of removing from a folder via 'none' is also already present in the folder parameter's schema description, so it adds no new 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 a specific verb and resource: move an existing assignment, and explicitly includes the 'out of any folder' behavior. This clearly distinguishes it from sibling tools like move_folders, which operate on folders rather than assignments.

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

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

There is no guidance about when to use this tool versus alternatives such as update_assignment or move_folders. The description does not state prerequisites, exclusions, or a reason to prefer this tool over related ones.

Agents often have multiple tools that could apply. Explicit usage 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 no annotations provided, the description carries the full behavioral burden. It exposes important traits: anti-cycle protection, partial failure behavior, and the dormant owner-keeping behavior while nested. It could mention more about permissions or response shape, but the key side effects 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 short, front-loaded with the core action, and every sentence adds value: the main behavior, anti-cycle handling, and ownership side effect. No filler or redundancy.

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

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

For a mutation tool with no output schema and no annotations, the description is quite complete: it covers purpose, bulk behavior, root destination, partial errors, and ownership effects. A minor gap is the lack of any return/error format description, but an agent has enough 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%, and both parameters are already well-described in the schema. The description reinforces the destination/root concept but does not add meaningful parameter semantics beyond what the schema already provides.

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

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

The description clearly states the action ('Move'), the resource ('assignment folders'), and a distinguishing scope ('SEVERAL ... in ONE call'). This makes it easy to differentiate from the sibling tool move_assignment_to_folder, which targets single moves.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 tool when moving several assignment folders under a new parent or to the root in a single operation. It does not explicitly name alternatives or state when not to use it, so it stops short of a 5.

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

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

With no annotations provided, the description carries the full behavioral burden and meets it thoroughly. It flags the action as DESTRUCTIVE, explains what gets permanently deleted (the account, detected viral posts, and assignments pointing at them), and states the required role. This is far more transparent than a typical deletion-tool description.

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

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

The description is compact and every sentence earns its place: a one-line purpose, a clear destructive warning with specifics, an authorization note, and a practical alternative. The front-loaded purpose and warning allow an agent to quickly understand the tool without navigating unnecessary prose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, single-parameter tool with no annotations and no output schema, the description is complete. It addresses what the tool does, the full scope of data loss, who is allowed to call it, and what to do instead if preservation matters. An agent has enough information to decide whether and how to invoke it.

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

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

The input schema already documents the sole 'account' parameter at 100% coverage, including accepted forms (username with or without @, or account id). The description adds no additional parameter-level semantics, 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 opens with a specific verb and resource: 'Remove an Instagram account from the watchlist.' It also clearly distinguishes the tool from related siblings like add_watchlist_account and list_watchlist_accounts by emphasizing the permanent, destructive nature of this removal.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 states when to use the tool and when not to: if the goal is to stop tracking without losing data, the description tells the agent to instead remove the account from the app after exporting needed data. It also includes the authorization prerequisite that only the org owner or an admin can perform this action.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. The verb 'Search' communicates a read-only operation, but the description does not state whether it returns a list of assets, how empty queries behave (though the schema does mention 'most recent'), or any access requirements. It adds no behavioral context beyond the schema and leaves some traits implicit.

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

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

The description is a single, front-loaded sentence that packs the resource, scope, and searchable fields with no filler. Every word contributes to meaning; it is appropriately minimal.

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

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

The tool is simple with two optional params fully documented in the schema. However, there is no output schema and the description does not state what the tool returns or whether it modifies anything. The absence of explicit return behavior creates a small gap, but the search operation is self-evident enough to be callable correctly using the 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%: both 'query' and 'limit' are documented with defaults, constraints, and meaning. The description's reference to searching by 'name, description or tags' mirrors the schema's query description and adds no additional parameter semantics. 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?

The description uses a specific verb ('Search') and identifies a distinct resource ('organization's asset library'), scoped to 'videos and images uploaded for content production' and the searchable fields (name, description, tags). This differentiates it from sibling tools like get_asset_download_url and update_asset, which target assets but for different 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?

The description provides clear context: use this tool to find assets by text over name, description, or tags. No explicit 'when not to use' or alternative is named, but there is no other sibling that searches the asset library, so the intended use is unambiguous. It lacks explicit exclusions or sibling comparisons, so not 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 are absent, so the description carries the full behavioral burden. It conveys the core mutation (assign or clear with 'none') and platform scope, but does not disclose overwrite behavior, whether the category must already exist, or what the tool returns. This is adequate but has gaps.

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

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

The description is a single, front-loaded sentence with no filler. It states the primary action first, includes the platform scope, and economically explains the 'none' clearing behavior.

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

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

For a low-complexity mutation tool with full schema coverage and no output schema, the description covers the essential call behavior: what action is performed, on what resource, and how to clear. It omits side effects like overwriting, but the tool is simple enough that the definition is sufficiently complete 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%, and each parameter (account, category, platform) already has explanatory text. The description's mention of clearing with 'none' is also present in the schema, so it adds no significant meaning beyond the structured fields. 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?

The description states a specific verb ('Assign') and resource ('watchlist account'), and adds platform scope (Instagram or TikTok). It is clear, though it does not explicitly differentiate from the similar sibling set_my_account_category; the 'watchlist' qualifier provides only indirect distinction.

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

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

No explicit guidance is given on when to use this tool versus alternatives like set_my_account_category or set_post_category. The description only implies the use case for watchlist accounts, and it never mentions exclusions or sibling 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?

With no annotations, the description carries the behavioral disclosure burden, and it does so well. It reveals the unlink path via 'none', enforces a single target, explains inheritance for production folders, states assignment precedence, and clarifies that future uploads route to the Drive folder. It stops short of mentioning overwrite behavior or response details, but the core side effects are transparent.

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

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

The description is two tightly packed sentences with no filler. The main linking action and target types are front-loaded, and the upload-routing consequence is stated in the second sentence. Every clause contributes useful information.

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

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

For a three-parameter tool with no output schema, the description is nearly complete for safe invocation. It covers targets, exclusivity, precedence, inheritance, and unlink behavior. The main gap is that neither the schema nor the description formally enforces exactly-one-of assignment_id/production_folder, which could leave an agent unsure whether a target is optional.

Complex tools with many parameters or behaviors need more documentation. 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 meaningful semantics beyond parameter names. It clarifies that assignment_id and production_folder are mutually exclusive targets, explains what inheritance and precedence mean, and gives the 'none' sentinel meaning for drive_folder.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Link' / 'unlink') with a clear resource ('a Google Drive folder') and names the exact targets ('production folder' or 'single assignment'). It also distinguishes this tool from siblings like create_drive_folder and get_drive_connection by describing the linking/set behavior rather than creation or connection checking.

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

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

The description gives a clear sense of when this tool is relevant: when the creator wants uploads for a target to go into a Drive folder. However, it does not explicitly state when not to use it, nor does it name alternative tools or exclusion conditions, so the agent must infer the usage boundary.

Agents often have multiple tools that could apply. Explicit usage 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 no annotations, the description carries the disclosure burden and does add meaningful facts: categories can be cleared with 'none' and an account holds at most one category. However, it does not explicitly say that assigning a new category overwrites the existing one, nor does it mention ownership/permission requirements or error behavior.

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

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

Two short sentences carry the purpose, the special clear value, the cardinality constraint, and the source for valid categories. There is no filler or redundant restatement of the input 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 simple three-parameter setter with fully described schema, this is nearly complete. It would be stronger with an explicit note about overwriting an existing category or a direct contrast with the similarly named set_account_category, but the current wording is sufficient for correct selection and invocation in most 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 100%, so the baseline is 3. The description adds a little semantic value by linking 'none' to the category parameter and clarifying that accounts come from the My Accounts scope, but it mostly reinforces what the parameter descriptions already say.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Assign a category'), a precise resource ('one of the org's own connected accounts (My Accounts)'), and the 'none' clearing behavior. Combined with the tool name, it clearly marks this as the My Accounts category setter, distinct from the sibling set_account_category.

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

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

It gives clear context: this tool is for the org's own My Accounts and points to list_my_account_categories for valid values. It does not explicitly call out when to prefer set_my_account_category over set_account_category or state exclusions, so it stops one step short of full routing guidance.

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

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

With no annotations provided, the description carries the burden of explaining behavior. It discloses the core mutation and the special 'none' clearing semantic, which is useful. However, it does not mention whether an existing category is overwritten, whether the category must already exist, or what response/error behavior to expect.

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

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

Single sentence with no redundancy. The primary action and scope are front-loaded, and the special 'none' clear behavior is appended without clutter.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 mutation with no output schema, the description is largely sufficient: it names the resource, supports batching, and explains the clearing option. It does not provide background on overwrite semantics or category existence, but those are secondary for basic invocation.

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

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

Schema description coverage is 100%, so the schema already documents post_ids as an array of UUIDs and category as an id/name or 'none'. The description adds domain context ('library posts', Instagram/TikTok) but does not add parameter-level detail beyond the schema, 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 identifies the action ('assign') and the resource ('category to one or more library posts'), while also noting the special 'none' clearing behavior. It distinguishes the post-level scope from sibling tools like set_account_category, though it does not explicitly name those alternatives.

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

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

The description gives clear context that this applies to library posts (Instagram or TikTok) and supports batch assignment, which helps an agent decide when to use it. It does not explicitly state when not to use it or name alternatives, but the resource scope is sufficiently specific.

Agents often have multiple tools that could apply. Explicit usage 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 no annotations, the description carries the burden of behavioral disclosure. It clearly states the core mutation (mark/unmark favorites) and connects it to downstream filtering, but it does not mention idempotency, partial failure behavior, permissions, or what happens when a favorite is toggled multiple times. For a simple toggle this is acceptable but not highly transparent.

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

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

The description is a single, tightly written sentence that front-loads the action and resource, then appends only a high-value parenthetical about the app star and the list_viral_posts filter. There is no redundancy or wasted wording.

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

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

For a simple two-parameter tool with no nested objects and no output schema, the description covers the action, the resource, the parameter semantics, and even the downstream effect on list_viral_posts. It doesn't discuss error cases or authentication, but those are less critical for such a focused toggle operation.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful semantic value: 'the same star as in the app' clarifies what 'favorite' means, and 'list_viral_posts favorites_only filters on it' tells the agent how the favorite flag is consumed. This goes beyond the bare parameter descriptions 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 uses a specific verb ('Mark or unmark') with a clear resource ('library posts as favorites'), and immediately explains that this maps to the app's star icon. It also mentions list_viral_posts' favorites_only filter, making the tool's role in the product unambiguous and differentiating it from sibling tools that manage categories or tags.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 useful context for when the effect matters: the favorite flag is the same star used in the app and is what list_viral_posts favorites_only filters on. It doesn't explicitly state when not to use it or name alternatives, but since no sibling tool directly manages favorites, the absence of exclusions is acceptable.

Agents often have multiple tools that could apply. Explicit usage 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 no annotations provided, the description carries the full behavioral burden. It usefully discloses the non-obvious multi-tag duplication behavior and that group counts do not sum to the total. It also conveys that this is an aggregate read-only operation via 'Roll up' and 'summarize', though it doesn't explicitly state no mutation occurs.

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

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

The description is tight and front-loaded: purpose and grouping dimensions first, then the use case, then a critical caveat. Every sentence earns its place, with no filler or schema repetition.

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

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

Given no output schema, the description does a good job enumerating what the tool returns (counts, status breakdown, followers, views, breakthrough posts). It doesn't cover edge cases like include_accounts=false behavior or exact output shape, but the rich parameter schema fills most remaining gaps.

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

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

Schema description coverage is 100% with detailed per-parameter explanations, so the description doesn't need to restate semantics. It adds a helpful grouping-duplication caveat that affects interpretation of the tags parameter, but this is a baseline-3 situation where the schema carries the load.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Roll up'), a clear resource ('the org's own connected accounts'), and the grouping dimensions (tag, category, platform). It clearly distinguishes this aggregation tool from siblings like list_my_accounts or get_my_account_stats, which operate at a different level of detail.

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

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

It provides a clear, concrete use case: 'This is the tool to answer "how are the accounts tagged X doing"'. However, it does not explicitly name alternatives or state when NOT to use it, so the routing guidance leaves some room for inference.

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

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

With no annotations, the description carries the behavioral burden. It discloses that the tool mutates tags, that it never creates tags, and that it returns the resulting set of tags. It does not cover permissions, error behavior, or reversibility, but the most important side-effect boundaries are stated.

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

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

Two sentences, front-loaded with the core purpose and followed by the key constraint and return behavior. Every sentence earns its place with 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?

The description covers the essential elements: what the tool does, the prerequisite for tags, and the return value. Since there is no output schema, stating that it returns the resulting tag set is important and helpful. Minor edge-case behaviors, such as overlapping add/remove tags or invalid account handling, are not addressed, but the description is complete enough for normal 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 adds a useful cross-reference to list_my_account_tags for valid tag values, but it does not meaningfully expand on the add_tags/remove_tags/platform parameters beyond what the schema already documents.

Input schemas describe structure but not intent. Descriptions should explain 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 specific verbs ('Add and/or remove') and a specific resource ('tags on one of the org's own connected accounts (My Accounts)'), clearly distinguishing this from siblings like tag_posts. It also names list_my_account_tags as the source of valid tags, reinforcing the tool's scope.

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

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

The description gives clear context: the tool operates on My Accounts and modifies existing tags. It explicitly states a precondition—tags must already exist in list_my_account_tags—and a boundary: 'this tool never creates one'. It does not explicitly name alternatives or exclusions, but the context is sufficient.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose useful traits: tags are normalized to lowercase/hyphens, and new tags are registered globally so they appear in filters. However, it omits other important mutation behavior such as what happens when the last tag instance is removed, idempotency, permissions, or return value.

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

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

The description is two concise sentences with no filler. The primary action is front-loaded, and the important side effects are stated immediately afterward without unnecessary detail.

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

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

For a moderately simple mutation tool with no annotations and no output schema, the description is nearly complete: it covers what is affected, the tag transformation rules, and global side effects. It falls slightly short only in not clarifying removal semantics and return behavior, which creates a small but non-critical gap.

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

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

The input schema already provides 100% coverage with descriptions for all three parameters, so the baseline applies. The description adds contextual value by explaining tag normalization and global registration, but no additional per-parameter semantics are necessary.

Input schemas describe structure but not intent. Descriptions should explain 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 'Add and/or remove custom tags', naming a specific verb, resource (posts), and scope (one or more). The phrase 'of the library (Instagram or TikTok)' plus 'custom tags' clearly distinguishes it from account-level tagging (tag_my_account) and global tag deletion (delete_tag).

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 scope of the operation is clear enough to infer that it applies to posts rather than accounts or global tag management. However, the description never explicitly states when to use this tool instead of alternatives like list_tags, delete_tag, or tag_my_account, leaving usage guidance mostly implied.

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

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

With no annotations present, the description carries the full burden. It discloses the core mutation behaviors, the ability to combine operations, and the important '@model' tag restriction. However, it does not describe persistence, permission requirements, response shape, or what happens if a disallowed edit is attempted, so some behavioral gaps remain.

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

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

The description is three tight sentences. The first sentence front-loads the action and all editable fields, the second gives batching guidance, and the third states the key constraint. Every sentence earns its place with no redundancy.

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

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

For a six-parameter mutation tool with full schema coverage, the description covers all operation categories and an important edge case. The asset identifier semantics are left to the schema, where they are well documented. A note about return behavior or failure modes would improve completeness, but the core call shape is well covered.

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

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

Schema coverage is 100%, so the schema already documents each parameter. The description adds meaningful parameter-level context beyond that: the '@model' tag is system-managed and cannot be edited, which directly informs add_tags and remove_tags. It also clarifies that separate operations can be combined in a single call.

Input schemas describe structure but not intent. Descriptions should explain 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 concrete action ('Update an asset of the library') and enumerates the exact operations it supports: rename, set notes, assign category, and add/remove tags. This clearly distinguishes it from sibling tools that target folders, assignments, categories, or accounts, and it does not merely restate the tool name.

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

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

The asset-specific scope makes the intended use clear, and 'Several operations can be combined in one call' gives actionable guidance to batch updates. It does not explicitly name alternatives or state when not to use the tool, but there is no competing 'update_asset' sibling and the context is reasonably 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 no annotations, the description carries full weight and discloses the key behavioral side effects: push notifications on approve/refuse, the dependency on a submitted video, and the deliberate exclusion of setting 'sent'. This exceeds the minimal 'updates an assignment' expectation and warns the agent about preconditions.

Agents need to know what a tool does to the 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: the first states the scope, and the second packs the behavioral constraints without redundancy. Every clause carries information, and it is front-loaded with the core action.

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

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

For a 6-parameter mutation tool with no annotations or output schema, the description covers the essential preconditions, side effects, and the main restricted value, and the schema covers parameter formats. It is slightly incomplete only in not describing the return value or error behavior when preconditions fail, but the invocation-relevant information 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?

Although the input schema documents all six parameters at 100% coverage, the description adds behavioral semantics to the status parameter that the schema lacks: 'approved'/'refused' require a submitted video and trigger a push, while 'sent' is restricted. This goes beyond the bare enum meanings, so a 4 is warranted.

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

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

The description opens with 'Update an assignment' and immediately enumerates the mutable attributes (production status, due date, note/brief, tags), making the tool's scope unmistakable. This clearly separates it from create_assignment, delete_assignment, and list_assignments among the 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?

It gives concrete conditions for the high-stakes status transitions: approving/refusing requires a submitted video and sends a push notification, and it explicitly states that 'sent' cannot be set through this endpoint. While it does not name an alternative tool, these preconditions and the 'cannot be set here' exclusion provide actionable when/when-not 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?

With no annotations, the description carries the burden and it does add 'Owner or admin only' authorization context. However, it does not disclose side effects on existing category assignments, whether the operation is reversible, or what happens on invalid input, so behavioral disclosure is only partial.

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

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

Two short sentences, front-loaded with the action and permission, with zero 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?

The tool is simple and the schema covers all parameters, but with no output schema and no annotations, the description omits likely side effects (e.g., cascading rename behavior) and response/error behavior. It is adequate for invoking the call, but not fully complete.

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

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

The schema already documents all three parameters with 100% coverage, including the empty-string-means-unchanged semantics. The description only restates rename/color at a high level and adds no new parameter detail, 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 states a specific action ('Rename a category and/or change its color') with a clear resource, and the permission note distinguishes it from create/delete/list category tools. It leaves no ambiguity about what update_category updates.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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: use it to rename or recolor a category, and it warns that only owner/admin can do so. It does not explicitly name alternatives such as create_category or delete_category, but the use case is clear enough for tool selection.

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

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

With no annotations, the description carries the full behavioral burden. It discloses non-obvious effects: archive cascades to the entire subtree, unarchive restores ancestors, and rename preserves subtree and assignment links. It does not describe side effects of owner changes or moves, but the key risk behaviors are covered.

Agents need to know what a tool does to the 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, front-loaded with the most important constraint ('ONE operation per call'), and every sentence provides non-redundant, actionable information. No filler or repetition.

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

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

For a 5-parameter mutation tool with no output schema and no annotations, this description covers operation semantics, subtree effects, and safe rename behavior. It is slightly incomplete because it does not clarify when to use archive_folder or move_folders instead, or what happens if multiple operations are supplied.

Complex tools with many parameters or behaviors need more documentation. 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 real value beyond the schema by clarifying that operations are mutually exclusive, explaining subtree cascading, and emphasizing that rename should not be done via delete-and-recreate.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Update an assignment folder') and enumerates the four operation types: rename, move, archive/unarchive, and owner change. It is clear but does not distinguish itself from the sibling archive_folder, which overlaps with the archive 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?

Provides strong usage constraints: ONE operation per call, and 'never delete and recreate to rename'. However, it never names alternative sibling tools such as archive_folder or move_folders, nor explains when to prefer them over this tool.

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