Viral Manager

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

The annotations only provide negative hints, so the description carries the burden of explaining behavior. It usefully discloses that the note is visible to the whole team, is authored by the MCP key's user, and is added to an existing thread. It does not mention idempotency or failure modes, but the core behavioral effect is well 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?

Two short sentences with zero filler. The action is front-loaded, and the second sentence provides meaningful behavioral context rather than redundant restatement.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 operation with no output schema and no safety annotations, the description adequately explains the effect, visibility, and authorship. It could mention response or error behavior, but that is 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?

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific detail beyond what the schema already provides: content is the note text and post_id is the target post. It reinforces the context but does not compensate for any schema gaps because none 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 action and resource: 'Add a note to the team's thread on a post.' It also clarifies the note's visibility and authorship, which distinguishes it from read-only note listing and from other post-level actions like tagging or favoriting.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 clear: call this when you want to add a team-visible note to a post's thread. There are no explicit alternatives or exclusions, but no sibling tool duplicates this capability (the related list_post_notes is read-only), so the usage 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?

Annotations already indicate this is a mutating, non-idempotent operation, so the description adds value by explaining the subscription requirement, account limit enforcement, and the automatic viral-post detection behavior. This goes beyond what annotations alone convey.

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

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

Two tightly packed sentences: the first states the core action and purpose, the second adds essential constraints. 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 single-parameter tool with no output schema, the description covers the action, the benefit, and the key prerequisites. It does not describe duplicate-account or limit-exceeded behavior, but that is not essential 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 coverage is 100%, and the username parameter is already well described with 'with or without @' and 'profile URL' details. The description does not add additional parameter-level semantics, which is acceptable given the high schema coverage.

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

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

The description opens with a specific verb and resource: 'Add an Instagram account to the user's watchlist'. It also states the intended effect ('so its viral posts get detected automatically'), which clearly distinguishes it from sibling tools like list_watchlist_accounts and remove_watchlist_account.

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

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

The description conveys clear usage context by stating the prerequisite of an active subscription and the plan's account limit. It does not explicitly exclude alternative tools, but the action is unambiguous enough that an agent can infer when 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?

The description goes well beyond the annotations by disclosing that the operation costs 1 credit, requires an active subscription, and runs asynchronously with a required polling workflow. It also mentions the 'already analyzed' case that avoids a credit charge, which is valuable side-effect context that annotations do not provide.

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

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

The description is compact and front-loaded: the core purpose appears first, followed by cost, subscription requirement, and the async polling behavior. Every sentence adds distinct, necessary 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 one-parameter tool with no output schema, the description explains the essential workflow: what input to provide, the cost and subscription constraint, and how to consume the result by polling get_post_analysis with the returned post id. Nothing critical is missing for an agent to invoke and follow up correctly.

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

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

The single parameter 'url' is already fully documented in the schema with examples of instagram.com/reel/... and tiktok.com/@user/video/...; the description adds no additional parameter-level semantics. With 100% schema description 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 states a specific action ('Import an Instagram or TikTok post URL and run the AI virality analysis') and clearly distinguishes the tool from siblings like get_post_analysis and get_post_preview by framing it as the initiating analysis step. The resource and behavior are unambiguous.

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

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

The description gives clear context on when to use the tool: when importing a post URL for virality analysis, requiring an active subscription, and noting the credit cost unless already analyzed. It names get_post_analysis as the follow-up for polling, but it does not explicitly state when to use alternatives like list_analyzed_posts to check existing analyses first.

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

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

Beyond the annotations, the description reveals important behavioral details: archiving cascades to subtrees, restoring also restores ancestors, and the operation is reversible unlike delete_folder. These are exactly the kind of non-obvious behaviors 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?

Three sentences with no fluff. The core capability is front-loaded, and each additional sentence adds unique value: batch nature, cascade/restore behavior, and a concrete usage example.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 key behavioral aspects, typical usage, and reversibility, which is enough for an agent to invoke this tool correctly. The only minor gap is that the action parameter is not explicitly described, but the enum and default make it reasonably discoverable.

Complex tools with many parameters or behaviors need more documentation. 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 folders parameter well. The description adds semantic weight to the action parameter by explaining archive versus restore behavior, but it does not explicitly map 'restore' to the 'unarchive' enum value. It compensates partially for the 50% schema description 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 the operation: archive or restore several assignment folders in a single call. It distinguishes itself from siblings like delete_folder by explicitly noting reversibility and batch 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 a concrete use case — a typical weekly reset — and explains that multiple week folders should be passed at once. It does not explicitly list when not to use it, but the guidance is clear and contextually useful.

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

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

The description substantially exceeds what the annotations alone provide. It discloses that archiving removes accounts from lists, stops sync, does not delete anything, is undoable, and that restoring consumes a plan slot and can fail. These details are not captured by readOnlyHint=false, idempotentHint=true, or destructiveHint=false, and nothing contradicts the annotations.

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

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

The description is compact and front-loaded: the first sentence states the main purpose, and each subsequent sentence adds distinct operational value such as side effects, reversibility, and failure mode. There is no filler or unnecessary repetition of schema fields.

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

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

For a mutating tool with no output schema, this description is highly complete. It covers what the operation does, what side effects occur, reversibility, the main failure condition, and how to select this tool over its destructive sibling. An agent has enough information 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 description coverage is 100%, so the schema already documents the accounts, archived, and platform parameters well. The description adds useful conceptual context about the archive/restore mental model and plan-slot cost, but it does not add new per-parameter format or syntax 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 clearly states the operation: archiving or restoring one or more of the org's own connected accounts. It also explicitly differentiates itself from delete_my_accounts by emphasizing that archiving is reversible and non-destructive, which distinguishes it from 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 description explicitly says to prefer this tool over delete_my_accounts whenever data might still be wanted, which is a concrete selection rule. It also warns about a real failure mode when restoring, LIMIT_REACHED, giving the agent useful expectations about when the operation can fail.

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

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

Annotations already indicate idempotent (true), destructive (false), and read-only (false). The description adds valuable behavioral nuance: the difference between leaving empty (keep current) and 'none' (detach), and the role-matching constraint. This goes beyond what annotations provide and clarifies the exact effect of each parameter 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?

Three tightly-packed sentences with zero redundancy. The purpose is front-loaded, then the value semantics, then the constraint. Every sentence earns its place and no space is wasted on 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 mutation tool with no output schema and annotations covering safety, the description provides everything needed: the action, the parameter semantics, the special values, and the constraint. It even points to list_crew for getting valid member IDs. 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?

Schema description coverage is 100%, and each parameter's schema description already lists the same value options. However, the description adds the global constraint that a member can only take the step matching their own role, and it clarifies the overall semantics of batch assignment. This supplements the schema with missing business logic.

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

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

The description clearly states the verb 'Set who edits, clips and posts' and the resource 'one or more assignments', explaining the production chain context. It distinguishes this from siblings like list_crew (which only lists) and update_assignment (which likely handles other assignment fields) by focusing specifically on crew roles.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 instructions on how to use each parameter (empty, name/member_id, 'none') and references list_crew for valid IDs, plus a constraint about role matching. However, it does not explicitly state when to use this tool versus alternatives like update_assignment, nor does it describe when not to use it, leaving that differentiation 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?

Beyond the sparse annotations, the description discloses real behavioral traits: creators receive a push notification, re-assigning an already-assigned post updates rather than duplicates, and the update is partial (only provided fields are refreshed). This gives the agent critical side-effect and mutation semantics that annotations do not convey.

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

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

Three dense sentences with no filler: the core action is first, followed by prerequisites and then important update/notification semantics. 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, side effects, and the update path, which is sufficient for a mutation tool with a fully documented schema. It could be slightly more complete by explicitly routing update-only intent to update_assignment or describing the success response, but these are minor gaps.

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

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

Input schema already documents all six parameters (100% coverage), so the baseline is 3. The description adds genuine value by clarifying the folder parameter's behavior ('applied as-is to every creator; per-creator folder auto-routing is not applied') and by connecting post_id/models to lookup tools, pushing it above baseline.

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

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

The description clearly identifies the action ('Assign a viral post to one or more creators') and the resource/scope, and even calls out the Production workflow. It does not, however, explicitly contrast itself with the sibling update_assignment or list_assignments, so it misses the explicit sibling differentiation that would earn a 5.

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

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

It states a concrete prerequisite ('post must already exist in the library') and points to relevant lookup tools (list_viral_posts / analyze_post_url). It describes the notification side effect and the re-assignment update path, but it does not say when NOT to use this tool or mention update_assignment as the alternative for updating an assignment.

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

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

The description adds a meaningful permission constraint—only org owner or admin can manage categories—which is not present in annotations. It also implies a mutating operation consistent with readOnlyHint: false. However, it does not describe duplicate-name behavior, whether categories are global, or what happens after 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 concise sentences deliver the core action, applicable resources, and permission requirement without extra filler. 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?

The tool is low-complexity with only two simple parameters and no nested objects, and the schema covers the parameter details. The description covers purpose, resource applicability, and authorization, but does not mention return values or duplicate-handling behavior, leaving a minor gap.

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

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

Both parameters are fully described in the schema, including the optional color default. The description adds no parameter-specific meaning beyond the schema, so baseline scoring 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 operation as creating a category, which is a specific verb and resource. It distinguishes the tool from set-like category assignment tools by noting the category is 'usable on watchlist accounts, posts and assets.' It does not explicitly name sibling alternatives, but the action and resource are unambiguous.

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

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

The description states a clear usage context: categories are used on watchlist accounts, posts, and assets, and only org owners or admins can manage them. It does not explicitly say when to choose this over set_post_category, set_account_category, or other assignment tools, leaving some routing to inference.

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

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

The description goes well beyond the sparse annotations by disclosing that the returned portal link is shown only once and must be kept in the answer, and that creating the member consumes one plan seat. It also explains the no-account/no-email behavior, which is material to how the agent should present the result.

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

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

Three tightly packed sentences deliver the action, the unique workflow, the one-time link warning, and the plan-seat side effect. Every clause earns its place, and the most important operational warning ('shown ONLY here') is emphasized 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?

With no output schema, the description fully covers the critical return value: the private portal link and the instruction to preserve it in the response. It also covers the seat consumption side effect and the no-account creation mode, making it complete for an agent to call and handle the result 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 parameter definitions already document name, role, and access_code. The tool description does not add significant parameter-level detail, though it does clarify the private-link context and the fact that a portal link is returned rather than account credentials.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Create a crew member'), the resource, the allowed roles ('editor, clipper or poster'), and the distinctive delivery mechanism ('private link'). It also distinguishes itself from sibling tools like list_crew and assign_crew by emphasizing the no-account, no-email creator-style workflow.

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

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

The description gives clear situational context: use this when you need a collaborator who works through a private link without an account or email. It does not explicitly name alternatives or exclusion conditions, but the private-link/no-account framing is enough to guide selection among the listed siblings.

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

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

Annotations already indicate this is a mutating, non-idempotent operation. The description adds useful behavioral context beyond that: folders 'stay writable by the app' and linking to a production folder has an immediate side effect on where creators' videos land. This helps the agent anticipate consequences.

Agents need to know what a tool does to the 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 focused sentences with no filler. The primary action is front-loaded, followed by the optional linking behavior and a relevant post-creation property. 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 low-complexity mutation with three parameters and no output schema, the description covers the essential context: what is created, where it can be placed, optional linking behavior, and resulting writability. It does not describe return values or error cases, but that is not critical for correct selection and 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 coverage is 100%, so parameters are already documented structurally. The description adds semantic value by explaining why link_to_folder matters (creators' videos land in the new folder) and clarifying parent_drive_folder placement (root or accessible Drive folder), going slightly beyond the raw schema.

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

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

States a specific verb and resource: create a folder in the organization's connected Google Drive. It also adds placement scope (root or accessible Drive folder) and the optional production-folder linking behavior, which clearly differentiates it from generic siblings like create_folder.

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

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

The description implies when to use the tool: when you need a Drive folder and optionally want creator videos to land in it via a production-folder link. However, it does not explicitly mention alternatives such as create_folder for non-Drive folders or set_drive_folder for linking existing folders later, and it gives no when-not-to-use guidance.

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

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

Annotations already indicate this is not read-only, not idempotent, and not destructive. The description adds meaningful behavioral context: a creator-owned ROOT folder 'becomes her bucket and drives per-creator routing.' This explains a non-obvious side effect beyond what the schema or annotations provide. It does not cover conflict/failure behavior, but the core mutation semantics are sufficiently 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 well-structured sentence with the core action front-loaded. Every clause earns its place: it names the resource, explains the optional parent, and clarifies the important owner/root routing consequence. There is no redundancy or filler.

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

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

For a create operation with three parameters and no output schema, the description covers the essential call semantics: required name, optional parent, optional owner, and the special root-folder behavior. It is slightly thin on what the caller should expect after creation, but it is complete enough for an agent to invoke the tool correctly.

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

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

The input schema already documents all three parameters at 100% coverage, so the baseline is 3. The description adds semantic value by explaining that parent placement is optional and that a creator-owned ROOT folder becomes a bucket affecting per-creator routing. This extends the schema's terse 'Only meaningful on a root folder' note.

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

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

States a specific action and resource: 'Create an assignment folder.' It differentiates from siblings like create_drive_folder and create_assignment by naming the resource type and clarifying the optional parent/owner semantics. The purpose is immediately identifiable.

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

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

The description implies when to use this tool — to create assignment folders, optionally nested or creator-owned. However, it does not explicitly contrast with alternatives such as create_drive_folder or create_assignment, nor does it state when not to use it. The context is clear but exclusionary guidance is absent.

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

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

The annotations already flag destructiveHint=true, but the description adds that deletion is permanent, signaling irreversibility and a batch scope ('one or more'). It does not expose additional side effects such as cascading deletion of related data, but the permanent/destructive nature is clearly 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 sentences carry exactly the needed information: the action/scope in the first sentence and the alternative/condition in the second. 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 simple one-parameter destructive tool, the description is complete: it names the operation, target, permanence, and the main alternative. The annotations cover safety, and the schema covers all parameters, so nothing needed for correct selection/invocation is missing.

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

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

Schema coverage is 100%, with assignment_ids documented as 'Assignment ids to delete' and constrained as a non-empty array. The description's 'one or more assignments' restates the schema without adding format, source, or example details, so it meets the baseline but adds no new semantic value.

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

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

The description states a specific action ('Delete ... permanently') on a specific resource ('assignments'), and the word 'permanently' distinguishes this destructive delete from softer status changes. It also names the sibling alternative, update_assignment, so an agent can tell the tools apart.

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

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

It explicitly says to prefer update_assignment (status refused) when the work should be redone, giving both an alternative and the precise condition for choosing it. This leaves no inference about when this tool is inappropriate.

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

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

Goes well beyond the annotations by disclosing the non-cascading behavior — dependent entities survive and merely lose the category reference — and the authorization requirement. destructiveHint already signals destruction, so the description's added value is precisely what gets destroyed and what does not, plus who is allowed to call it.

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

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

Three short sentences, each earning its place: the action, the behavioral consequence, and the access restriction. Front-loaded verb+resource with zero filler or repetition of schema content.

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

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

Complete for the common case: purpose, effects on dependent entities, and permissions are all covered for a one-parameter mutation. Minor gaps remain — behavior when the category does not exist, resolution of duplicate names, and the response shape, especially given there is no output schema — so it is not a full 5.

Complex tools with many parameters or behaviors need more documentation. 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% ('Category to delete (id or name)'), so the schema fully documents the parameter. The description adds no additional parameter detail, such as how name collisions are resolved or how id versus name lookup behaves, landing it at the baseline 3.

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

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

States a specific verb and resource ('Delete a category'), which cleanly distinguishes it from siblings like create_category, update_category, and list_categories. It also differs from other delete tools (delete_tag, delete_assignment, delete_folder) by naming the exact resource.

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

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

The description conveys when the tool is appropriate by explaining the postconditions (referencing accounts, posts, and assets are preserved) and the permission constraint (owner or admin only). However, it never names alternatives or states when-not-to-use, leaving the agent to infer the choice versus update_category or other category-scoped 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?

Beyond the destructiveHint annotation, it discloses permanence, recursive subfolder deletion, and the fact that assignments survive but lose their folder. These are exactly the behavioral details an agent needs before invoking a destructive tool.

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

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

Two tight sentences front-load the critical permanence warning and pack the cascade behavior and reversible alternative into minimal words. No filler or redundant restatement of the schema.

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

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

For a one-parameter destructive tool with annotations and a fully documented schema, the description covers the key effects, irreversibility, and the safer alternative. Nothing essential is missing for correct selection and 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 schema already fully documents the single 'folder' parameter, including accepted forms (id, name, or full path), and the description adds no parameter-specific meaning. With 100% schema coverage, 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 ('Delete') and resource ('assignment folder'), and clarifies that deletion is permanent and cascades to subfolders while preserving assignments. This clearly distinguishes it from update_folder/archive_folder and delete_folders in the sibling list.

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

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

It explicitly directs the agent to prefer update_folder with archive when reversibility is desired, establishing the key when/when-not boundary. The permanent/cascade semantics imply use this tool only when irreversible deletion is the intended outcome.

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?

Even though destructiveHint=true already signals destructiveness, the description adds meaningful behavioral context: multiple folders are deleted in one call, deletion is permanent, subtrees are removed, and contained assignments survive but lose their folder association. This goes well beyond the annotation and helps the agent predict side effects.

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

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

The description is compact and front-loaded: the critical facts (permanent, multi-delete, one call) appear first, followed by behavioral side effects and the safer alternative. No sentence is wasted.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 destructive tool with clear annotations and no output schema, the description covers everything an agent needs: what is deleted, what is preserved, irreversibility, and the safer alternative. No critical operational detail is missing.

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

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

Schema coverage is 100% and the schema already documents that the 'folders' parameter accepts an array of ids, names, or full paths. The description adds the notion that multiple folders are expected and that they are assignment folders, but it does not need to explain parameter mechanics further.

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

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

The description names a specific verb ('Delete'), a specific resource ('assignment folders'), and key scope qualifiers ('SEVERAL', 'PERMANENTLY', 'in ONE call'). It also clarifies edge behaviors ('subtrees are deleted too; assignments inside are kept but lose their folder'), which distinguishes it clearly from singular or reversible alternatives like delete_folder and archive_folder.

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

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

The description explicitly recommends archive_folder as the reversible alternative, giving clear guidance to prefer it when reversibility matters. It implies that delete_folders is for cases requiring permanent bulk deletion, though it does not fully spell out all when-not-to-use 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?

The description goes well beyond the destructiveHint annotation by detailing the full blast radius: the account, posts, stats, tags, scheduled posts, and the Instagram/TikTok connection are all permanently removed. It also discloses irreversibility, the distinction from disconnecting, and the confirm-flag behavior, giving a complete picture of consequences.

Agents need to know what a tool does to the 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 but rich: it front-loads the destructive verb and scope, lists the cascade of deletions, flags non-reversibility, distinguishes from disconnecting, names the alternative, and gives a typical use case. Every sentence earns its place 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?

This is a destructive, multi-account deletion tool with three parameters, and the description covers all decision-relevant aspects: what gets destroyed, how to distinguish from safer alternatives, when it's appropriate, and the confirmation mechanism. The schema covers parameter details, and annotations cover the destructive flag, so nothing critical is missing.

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

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

Schema description coverage is 100%, so the schema already fully documents all three parameters. The description adds high-level context about the accounts parameter ('org's own connected accounts') and reinforces the confirm behavior, but it does not add meaning beyond the schema's own detailed parameter descriptions. 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 verb ('delete'), a precise resource ('org's own connected accounts — My Accounts'), and a clear scope ('one or SEVERAL... in one call'). It also enumerates exactly what is deleted and explicitly distinguishes itself from archive_my_accounts, so an agent can unambiguously identify this tool.

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

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

The description provides explicit when-to-use guidance ('cleaning up burner accounts that got banned or checkpointed and will never come back') and names the alternative ('use archive_my_accounts instead') with the reasoning why. This gives the agent concrete decision criteria for choosing between destructive deletion and archival.

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

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

The annotations already mark this as destructive, but the description goes further by explaining exactly what gets destroyed: the tag is removed from every post, every asset, and the global registry. It also implies the operation is not scoped to a single item, which is critical behavioral context beyond the destructiveHint annotation.

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

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

The description is two sentences with no filler. The critical scoping information ('EVERYWHERE') is front-loaded, and the alternative guidance is compactly delivered. 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 single-parameter destructive tool with no output schema, the description provides everything an agent needs: what the tool does, the global scope, and when to use a sibling tool instead. The schema fully documents the only parameter, so there are no ambiguous fields or missing invocation details.

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

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

The single parameter 'tag' has a schema description that covers 100% of its meaning: 'Tag to delete (as shown by list_tags)'. The main description adds no additional parameter-level semantics, so the schema carries the weight. This matches the baseline for high schema coverage.

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

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

The description states a specific verb ('Delete'), a clear resource ('a tag'), and a precise scope ('EVERYWHERE... 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 by emphasizing the global removal 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 explicitly tells the agent when NOT to use this tool and names the alternatives: 'Use tag_posts / update_asset with remove_tags to untag individual items instead.' This provides clear routing guidance between delete_tag and the less destructive sibling operations.

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

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

Beyond annotations (readOnlyHint=false, idempotentHint=true), the description discloses key behaviors: sending again replaces the note, recipients are notified by push, and the planning mechanism for variations. It also clarifies the meaning of from_member and from_stage in context, adding substantial value over 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 structured and efficient: it leads with the primary purpose, then details the two modes, and adds relevant context (notification, id source) without redundancy. Every sentence contributes to understanding, and the length is justified by the tool's complexity.

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

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

Given the tool's complexity (7 parameters, two modes, no output schema), the description is complete. It explains the planning flow, recipient order, and prerequisite data source, and it does not leave critical ambiguities. The lack of an output schema is acceptable since return values are not needed for calling.

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

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

Schema description coverage is 100%, so each parameter is individually documented. The description adds meaning by explaining the interplay between video_id and variation, the conditional use of from_stage, and the significance of recipient ordering. This goes beyond the schema, though it does not exhaustively elaborate every parameter.

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

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

The description clearly states the tool's action ('Send a delivered video... to one or several crew members') and its resource (assignment video), and distinguishes two modes (send existing video vs. plan a variation). It differentiates from sibling tools like remove_dispatch by explicitly covering the dispatch/planning action.

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

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

The description explains when to use each mode (with or without video_id) and the ordering of recipients, and it references get_assignment for obtaining video ids. It does not explicitly name alternative tools or state when not to use this tool, but the dual-mode guidance is clear enough for most use cases.

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?

All annotations are false hints, so they add no safety profile and the description carries the disclosure burden. It discloses meaningful side effects beyond the schema: copied assignments get a fresh 'pending' status, the subfolder tree is recreated, Drive links are excluded, and owner_model reassigns all copied assignments. Gaps are minor (name-collision behavior, return value), and there is no contradiction with the annotations — the described mutations align with readOnlyHint=false.

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

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

Three sentences with no filler, each serving a distinct purpose: core copy behavior, the template-clone use case, and the Drive-link exclusion with its alternative. The primary purpose is front-loaded and 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 five-parameter mutating tool with no output schema and neutral annotations, the description combined with the richly documented schema covers what an agent needs to call it correctly: what gets cloned, how ownership reassignment works, and the Drive-link limitation. What's missing is post-call information — the identity/return value of the copy (needed to chain set_drive_folder) and behavior on name collisions — which prevents a 5.

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

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

Schema coverage is 100% and the schema descriptions are already detailed (e.g., owner_model explains reassignment and root-folder ownership; new_name explains the '<source name> (copy)' default). The description adds useful color — cloning a template for a new creator and what 'copies its assignments' means (posts, brief, tags retained, status reset) — but it mostly reinforces rather than fundamentally extends the schema's parameter documentation.

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

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

States a specific verb and resource ('Duplicate a folder') and goes well beyond a tautology by specifying exactly what duplication entails: recreating the subfolder tree and copying assignments with same posts, brief and tags but fresh 'pending' status. This detail distinguishes it from siblings like create_folder (empty folder), move_folders (relocation), and archive_folder (status change).

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 an explicit when-to-use scenario: cloning a template folder like 'Beginner content' for a new creator via owner_model. Also gives a concrete exclusion with an alternative: 'Drive links are not copied (use set_drive_folder on the copy)'. It does not systematically contrast with all folder-operation siblings (e.g., when to choose create_folder over this), 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?

The description adds significant behavioral detail beyond the readOnlyHint annotation: it explains that download_url forces a file download with a clean filename and expires in 24h, while file_url is a permanent public URL. This is exactly the kind of operational nuance an agent needs to select the right URL and is not derivable from annotations or 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 sentences with no redundancy. It front-loads the primary purpose, then packs essential URL behavior (expiration, filename forcing, permanence) into the second sentence. Every clause earns its place, keeping the description compact and 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?

With no output schema, the description names the two key return fields (download_url and file_url) and their validity/permanence, which is strong. However, it is slightly ambiguous how the thumbnail URL maps to these fields—the description says URLs for the original plus its thumbnail but does not explicitly specify which returned property corresponds to the thumbnail. Given the tool's simplicity and the valuable details provided, this is a minor gap.

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

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

Schema description coverage is 100%, and the schema already documents 'asset' as 'id from search_assets, or exact name'. The tool description itself does not add new parameter semantics beyond restating that the asset belongs to the library. Since the schema carries the full load, a baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Get') and a clear resource ('downloadable URLs for an asset of the library'), and explicitly distinguishes the asset context from sibling tools like get_post_download_url by mentioning the library and the original file plus thumbnail. This makes the tool's purpose unambiguous and differentiable from related download-URL 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 a clear use context: 'e.g. to save it or send it to another service like a Drive.' It also scopes the tool to 'an asset of the library,' which implies when it should be used versus tools for posts or my-account posts. However, it does not explicitly name alternative tools or state when not to use this tool, so it falls just short of full exclusion guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, and the description aligns with that by framing the operation as a read. It adds useful behavioral context by disclosing the returned content categories, including videos as URLs, which is beyond what annotations provide. It does not discuss error behavior or auth, but those are less critical for a simple read 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?

A single, front-loaded sentence that states the purpose first and then efficiently enumerates the detail components. No filler or redundant 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 one-parameter read-only tool with strong annotations and full schema coverage, the description is complete. It tells the agent what the tool returns and how to source the parameter, leaving no critical gap for selecting and invoking it correctly.

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

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

Schema description coverage is 100%, with assignment_id already described as coming from list_assignments. The tool description adds no additional 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 states a specific verb ('Get') and resource ('one assignment'), then lists the exact detail components returned: notes, reply thread, due date, and submitted video URLs. This clearly differentiates it from sibling tools like list_assignments, create_assignment, and update_assignment.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 it clear this tool is for retrieving full detail of a single assignment, and the parameter description points agents to obtain assignment_id from list_assignments. It does not explicitly name alternatives or state when not to use it, but the use case is unambiguous enough.

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

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

The readOnlyHint annotation already signals a safe read operation, lowering the bar. The description adds useful detail about what stats are included but does not explain behaviors like time ranges, caching, or how 'recent activity' is defined. It is adequate but not richly 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?

A single, front-loaded sentence identifies the resource and immediately lists the key stat categories. 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 parameterless, read-only dashboard aggregate, the description provides enough category-level detail for an agent to understand what will be returned. The terms 'analyses' and 'recent activity' are slightly vague, and there is no output schema, so a bit more precision about returned fields could strengthen completeness.

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

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

The tool has zero parameters and the schema fully covers this with an empty properties object. With no parameters to document, the description does not need to compensate for schema gaps, so the baseline of 4 applies.

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

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

The description clearly states the tool retrieves organization-level dashboard stats and enumerates the included categories: watchlist size, viral post counts, analyses, and recent activity. This differentiates it from sibling tools like get_my_account_stats, which target 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 implies use for organization-wide aggregate statistics, which gives clear context against account-specific siblings. It does not explicitly name alternatives or state when not to use this tool, but the organization versus my-account distinction in the description provides reasonable guidance.

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

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

The readOnlyHint annotation already indicates no mutation, and the description adds meaningful behavioral context: connecting requires a Google consent screen, is manager-only, and is done via the app rather than this tool. It also clarifies what the MCP becomes capable of once connected. It does not describe the exact status response format, but that is a minor gap for a parameterless read-only check.

Agents need to know what a tool does to the 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 the core purpose front-loaded. The second sentence adds valuable operational detail about how the connection is established and what capabilities become available, so the length is justified. It is concise while still providing necessary context.

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

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

For a simple parameterless status tool with readOnlyHint and openWorldHint annotations, the description covers the main purpose, the connection setup flow, and downstream capabilities. The only notable omission is the concrete return values (e.g., connected vs. not connected), but the word 'Status' and the surrounding context make the tool's behavior 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?

The tool has zero parameters and schema description coverage is 100%, so there is nothing for the description to add about parameters. The baseline of 4 applies because no parameter documentation is needed.

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

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

The description clearly identifies the tool as returning the status of the organization's Google Drive connection and explains why that connection exists (storing creators' submitted videos in Drive). This distinguishes it from drive-manipulation siblings like create_drive_folder, list_drive_folders, and set_drive_folder.

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

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

The description provides explicit context: the connection can only be established by a manager through the app UI, not through this MCP. It also states that once connected, the MCP can list/create Drive folders, implying this status check should precede such operations. This gives practical usage guidance beyond a simple tool label.

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

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

Beyond the readOnlyHint=true and openWorldHint=true annotations, the description discloses rich behavior: live resolution from the official API with the account's own token, URL expiry of a few hours, and platform-specific fetch constraints (TikTok needs session cookies for a browser-like fetch). These details materially affect how an agent should consume the result and are not present in the annotations. No contradiction with annotations.

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

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

Three sentences with zero waste: core purpose front-loaded, followed by two dense platform-specific caveats that are essential for correct usage. Every sentence earns its place, and the Instagram/TikTok split is cleanly structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 whose schema fully documents that parameter, the description covers the behavioral complexities (expiry, token, cookies) and implies the response shape (a URL, plus cookies in the TikTok case). The only gap is the absence of an exact response schema, but an agent still has enough to call and interpret 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 coverage is 100% and the post_id property is already fully described ('Post id (UUID, the id field from list_my_account_posts)'). The description reinforces that the post belongs to the org's own My Accounts and adds that the URL is for a video, but it adds little beyond the schema, so the baseline 3 applies.

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

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

The description states a specific verb+resource: 'Get a downloadable URL for the video of one of the org's OWN posts (My Accounts).' It also distinguishes itself from sibling tools like get_post_download_url and get_asset_download_url by explicitly scoping to the org's own My Accounts posts, so an agent can tell them apart without opening 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 clear operational context: Instagram URLs resolve live and expire after a few hours (use immediately), while TikTok URLs require returned session cookies and usually cannot be fetched by external services. The '(My Accounts)' qualifier implies the scope boundary versus general-post tools, but no sibling is explicitly named and no when-not-to-use condition is stated.

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

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

The annotations already declare readOnlyHint=true, so the read-only nature is covered. The description adds useful scoping and output content, but does not mention behavioral details such as rate limits, authentication requirements, or potential data staleness.

Agents need to know what a tool does to the 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 purpose and then lists the key output categories. There is no redundant wording or filler.

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

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

For a two-parameter read-only tool with no output schema, the description adequately covers what the tool returns and for which accounts. Parameter details are fully handled by the input schema, and no critical usage gap remains.

Complex tools with many parameters or behaviors need more documentation. 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 fully documents both parameters: account accepts a username, display name, or id from list_my_accounts, and platform disambiguates identical usernames. Since schema coverage is 100%, the tool description adds no parameter-specific 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 names a specific verb ('Get') and resource ('growth stats of one of the org's own connected accounts') and lists the concrete output content: followers/views history, breakthrough count, and top posts by views. This distinguishes it from siblings like get_dashboard_stats, list_my_accounts, and list_my_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?

The description clearly scopes the tool to individual 'My Accounts' belonging to the org, which separates it from watchlist or dashboard-level tools. It does not explicitly name alternative tools or say when not to use it, but the context is unambiguous enough for an agent to route correctly.

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

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

Annotations already mark this as read-only, and the description adds useful behavioral nuance by noting the AI analysis is only included 'when available' and enumerating its components. This helps set expectations without contradicting the annotations.

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

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

A single well-structured sentence that front-loads the primary action and detail, then adds the source-of-id guidance. No wasted words; every part earns its place.

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

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

For a simple read-only single-parameter tool, the description covers what the result contains, the conditional analysis, and how to obtain the id. It does not detail the full return structure, but with no output schema and a straightforward resource, the provided context is sufficient.

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

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

Schema coverage is 100%, with post_id described as 'Post id (UUID) or Instagram shortcode'. The description adds that the id should come from list_viral_posts or list_analyzed_posts, reinforcing usage but not adding materially new parameter semantics.

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

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

The description uses a specific verb ('Get') and resource ('full detail of one viral post'), and it states the unique value-add: the AI analysis with hook, structure, why it went viral, and replication guide. This clearly distinguishes it from the sibling list tools and preview 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 explicitly tells the agent to pass the post id returned by list_viral_posts or list_analyzed_posts, which provides clear context for when this tool is appropriate. It does not mention when not to use it or name alternatives, but the provenance guidance is strong.

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

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

Annotations already provide readOnlyHint=true, but the description goes further by disclosing two critical runtime behaviors: AI-analyzed posts yield a permanent copy via source 'permanent_copy', while other URLs may be temporary CDN links, and TikTok CDN links often refuse non-browser downloads. This is valuable context beyond the structured annotation.

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

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

The description is two tight sentences. The first covers what the tool does and a motivating use case; the second covers the key caveat about permanent vs expiring URLs. Every sentence earns its place, and critical technical details are 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 read-only tool with no output schema, the description is complete enough: it names the resource, the use case, what is included in the result (video plus thumbnail), and the important behavioral caveats. An agent can 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 single post_id parameter is fully documented in the schema with its UUID type and origin from list_viral_posts / list_analyzed_posts. The description reinforces the relevance of post_id but adds no new parameter-level semantics, so the baseline 3 for high schema coverage 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 a downloadable URL') and a well-defined resource ('a library post's video file plus its thumbnail'). The phrase 'library post' clearly distinguishes this from sibling tools like get_asset_download_url and get_my_account_post_download_url, and the use case ('save it or send it to another service') reinforces the intent.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 why someone would use this tool: to save a video or send it to another service like Drive. It also warns about conditions under which the URL may not work well. However, it does not explicitly name alternatives or state when not to use this tool versus sibling download tools.

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

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

Annotations already declare readOnlyHint=true, so the description is not required to restate safety. It adds useful behavioral detail beyond annotations: the tool 'returns the image inline plus the video URL when available', clarifying the output shape and the conditional nature of the video URL. This is valuable context for an agent invoking the 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?

Three short sentences with no filler: the first states the core function and user benefit, the second specifies allowed post sources, and the third describes the return value. Each sentence contributes necessary information and is front-loaded appropriately.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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-only tool, the description covers the essential invocation context: valid post sources and the expected return (inline image, optional video URL). It does not detail the exact inline format or error behavior, but given no output schema exists, the description is still sufficiently complete for an agent to call it effectively.

Complex tools with many parameters or behaviors need more documentation. 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 post_id property is already described as a UUID from list_viral_posts, list_analyzed_posts, or an assignment. The tool description reinforces this source restriction but does not add new 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 uses a specific verb and resource: 'Get the visual preview (thumbnail image) of a post', and clearly distinguishes this from sibling tools by emphasizing the inline image display for conversation. It also narrows scope to 'viral posts' and 'posts referenced by an assignment', making it unambiguous what this tool does and how it differs from downloads or analyses.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 the user needs to see a preview inline in the conversation, and specifically for posts from the org's viral list or assignments. It does not explicitly name alternatives or state when not to use it, but the context is strong enough to guide selection among siblings.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds a meaningful behavioral nuance: it returns a 'current snapshot', implying point-in-time data rather than a historical or exhaustive list. This is useful context beyond the annotations.

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

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

The description is a single, well-structured sentence that front-loads the core action and resource, then adds the optional filter. Every word earns its place 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 read-only tool with two fully documented optional parameters, the description and schema together provide enough context for an agent to call it correctly. There is no output schema, but the return concept ('trending sounds') is clear enough for a tool of this 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 schema already documents both `limit` and `niche` with meaningful descriptions. The tool description adds only that results are 'optionally filtered by niche', which aligns with the schema but does not meaningfully extend it.

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

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

The description uses a specific verb ('Get') and resource ('trending sounds'), and clarifies the domain as 'music rising on Instagram Reels'. This clearly distinguishes it from sibling tools, none of which target trending sounds.

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

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

The description implies usage context by describing a 'current snapshot' and optional niche filtering, but it does not explicitly state when to prefer this tool over alternatives or provide any exclusion criteria. The intended use is inferable, though not spelled out.

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

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

Annotations already declare readOnlyHint=true, so the description is not burdened with restating safety. It adds useful behavioral details: results are filtered to posts with completed AI analysis, sorted newest first, and presentation should include the url link. There is no contradiction with annotations, and the remaining gaps around response structure are minor for a simple read-only list.

Agents need to know what a tool does to the 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 with no filler. The first sentence front-loads the core purpose and ordering; the second adds a concrete presentation requirement. 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?

For a simple read-only listing tool with two optional parameters, the description covers the key selection criterion, ordering, and a user-facing presentation rule. It does not enumerate all return fields, but the url requirement and the schema provide enough for correct invocation. Slightly more detail about what 'completed AI analysis' implies could make it fully complete.

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

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

Schema description coverage is 100%, with limit and offset fully documented in the input schema. The description adds no parameter-specific detail beyond the default ordering implied by 'newest first'. Since the schema already carries the parameter semantics, 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 names a specific verb and resource: list posts that already have a completed AI analysis, ordered newest first. This clearly separates it from siblings like get_post_analysis or list_viral_posts without requiring schema inspection. The tool's name is not merely restated; the filtering and ordering criteria are explicit.

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

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

The description provides some usage context by instructing the agent to include each post's url link when presenting posts and references get_post_preview for thumbnails. However, it does not explicitly state when to prefer this tool over other listing tools or when not to use it. Selection guidance is implied rather than directly stated.

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

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

Annotations already mark the operation read-only, and the description adds useful behavioral context beyond that: it defines what each status means, notes that an assignment is validated as soon as the video is received, and instructs that post_url should be included when presenting results. There is no contradiction with annotations.

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

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

The description is compact and front-loaded: it states the tool's purpose first, then defines statuses and output expectations. Every sentence earns its place without excessive 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 read-only listing tool with 100% schema parameter coverage, the description covers scope, status semantics, crew association, and an output expectation (post_url). It does not describe full return rows or pagination, but those are not critical given the readOnlyHint and limit parameter.

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

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

Schema description coverage is 100%, so the baseline is 3; each parameter is already documented in the schema. The description adds contextual framing around statuses, but it does not add meaning to individual parameters 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 uses a specific verb ('List') and resource ('content assignments'), defines what assignments are, and lists the distinguishing data included (status and crew. It differentiates from siblings like get_assignment, create_assignment, and update_assignment by framing itself as an organization-wide listing tool.

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

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

The description gives clear context for when to use the tool: whenever the user needs assignments with production status and attached crew. It does not explicitly name alternative tools or state when not to use it, but its listing purpose is clear enough that an agent can infer appropriate use.

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

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

The readOnlyHint annotation already establishes that this is a safe read operation, and the description matches that by saying 'List'. The added detail about categories being shared is useful domain context, but the description does not disclose any further behavioral traits such as pagination, ordering, or output structure.

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

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

The description is two short sentences with no filler. The main action and resource are front-loaded, and the second sentence adds one meaningful distinguishing fact. 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 zero-parameter, read-only list operation, the description is largely complete: it identifies the resource, scope, and shared nature of categories. The only minor gap is that it does not describe the returned category fields or any pagination behavior, though the absence of an output schema makes this less 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 and the schema fully documents this by defining an empty properties object. There is nothing for the description to add about parameter meaning, so the schema carries the complete semantic burden as expected.

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

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

The description uses a specific verb ('List') with a clear resource ('the organization's categories') and adds a distinguishing detail—categories are shared across watchlist accounts, library posts, and assets. This differentiates it well from sibling tools like list_my_account_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 signals that this returns organization-wide, shared categories rather than account-specific ones, which gives an agent the context needed to choose it over list_my_account_categories. It does not explicitly name an alternative or provide exclusion criteria, but the scope is clear enough.

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

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

Annotations already declare readOnlyHint=true. The description adds value by stating the portal link is not returned and explaining role ordering per post, providing behavioral detail beyond the annotation.

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

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

The description is a few sentences with no fluff; it front-loads the purpose, then explains roles, usage, and caveats in a logical order. Slightly long but every sentence earns its place.

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

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

Given no output schema, it implies the return includes member_id and name (via 'use the returned member_id or name') and explicitly states what is not returned. It's complete for a simple list operation with one optional parameter.

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

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

Schema coverage is 100% with a property description, but the tool description enriches the role enum by defining each role's function (creator films, editor edits, clipper cuts clips, poster publishes), adding meaning 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 production crew (editors, clippers, posters) with specific roles and their per-post ordering. It's a specific verb+resource that distinguishes it from other list_* tools.

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

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

It explicitly instructs to use the returned member_id/name with assign_crew, and notes the private portal link is not returned here, directing to create_crew_member or the app. This gives clear when-to-use and what-not-to-expect context.

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

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

Annotations already provide readOnlyHint and openWorldHint, so the bar is lower. The description adds useful context about the drive.file scope and the source of these folders, but does not go into return format or other behavioral details. This is adequate but not exceptional.

Agents need to know what a tool does to the 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 information-dense sentence with a clear follow-up instruction. It is front-loaded with the tool's main purpose, though the phrase 'production folders / assignments currently linked' is slightly ambiguous and could be clearer.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, zero-parameter tool with an openWorldHint, the description covers what is listed, why it is scoped that way, and how to use the result. Return format is not specified, but this is acceptable given the absence of an output schema and the simplicity of the tool.

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

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

The input schema has zero parameters and schema coverage is effectively complete, so the description does not need to explain parameters. The baseline of 4 applies, and the mention of using returned ids with set_drive_folder reinforces the no-parameter contract.

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

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

The description states a specific verb ('List'), a specific resource ('Google Drive folders'), and an explicit scope ('folders this app can write into'). It also distinguishes itself from generic folder tools by mentioning the drive.file scope and the link to production folders/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?

The description gives clear context on what the tool lists and closes with an explicit usage pointer: 'Use the ids with set_drive_folder.' It does not name alternatives or exclusions, so it stops short of a full 5.

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

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

Annotations already mark this as readOnly, and the description adds meaningful behavior: a folder has no crew owner, visibility is mediated through posts, and the result includes nested crew members and post counts. This goes beyond the simple readOnly annotation and explains the access model.

Agents need to know what a tool does to the 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 deliver purpose, domain context, and a selection rule without any filler. The most important behavior is front-loaded and every sentence adds information the agent needs.

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

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

With no output schema, the description carries the return-format burden and explicitly names tree structure, key identifiers, creator, archive flag, associated crew, and post count. Given the small parameter set and readOnly annotation, no essentials are missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds valuable semantics for `crew`, explaining why the parameter exists and how folder membership is determined, and clarifies how `include_archived` fits into the output ('archived flag').

Input schemas describe structure but not intent. Descriptions should explain 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 opens with 'List the organization's assignment folders as a tree', naming the specific verb, resource, and output structure. It clearly distinguishes assignment folders from related siblings like list_drive_folders and list_assignments by specifying crew and post context.

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

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

Provides clear context for use: folders are per-owner containers and crew visibility is driven by post attachments. It also gives explicit guidance to use the `crew` parameter to list a specific person's folders, though it does not name excluded alternatives.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, covering the safety profile. The description adds useful context beyond the annotations by specifying that results are limited to creators eligible for content assignments and that the output contains model_id and name/email for use downstream.

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

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

Two sentences with no filler: the first states the core purpose, the second explains how to use the result. Every word 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 tool with no parameters and no output schema, the description is complete: it defines the return payload enough (model_id, name/email) and tells the agent how to consume it. No prerequisites, permissions, or edge cases are needed for a simple list 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 input schema is empty with zero parameters, so no parameter documentation is needed. The baseline of 4 applies for 0-param tools, and the description appropriately avoids inventing parameter details.

Input schemas describe structure but not intent. Descriptions should explain 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 ('creators (models) of the organization who can receive content assignments'), making its purpose unmistakable. It is clearly distinct from sibling list tools like list_assignments and list_categories because it names the exact entity type and eligibility scope.

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

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

The description provides explicit downstream guidance: 'Use the returned model_id (or the name/email) with create_assignment,' telling an agent when this tool is relevant. It does not explicitly say when not to use it or mention alternatives, but the linkage to create_assignment gives sufficient 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?

The readOnlyHint annotation already signals a safe read operation, and the description adds useful scope context about My Accounts. However, it does not disclose additional behavioral details such as return format, ordering, or whether empty results are possible. The description is consistent with annotations and provides moderate added 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 compact and front-loaded, stating the main purpose first and then the differentiating scope note. Every sentence earns its place, with no filler or repetition of schema or annotation 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 zero-parameter, read-only list tool with a simple scope, the description is complete. It names what is listed, which accounts it applies to, and how it differs from the closest sibling. No output schema exists, but the lack of parameters and straightforward purpose keep the context burden low.

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

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

This tool takes zero parameters, so there is no parameter semantics burden. The description confirms the operation context without needing to explain any input fields. Per the rubric, zero-parameter tools receive 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 uses a specific verb and resource ('List the categories available to organize the org's own connected accounts') and explicitly distinguishes the tool from list_categories. This makes the purpose immediately clear and disambiguates it from the sibling tool.

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

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

The description explicitly tells the agent when to use this tool versus the alternative: it covers My Accounts categories, while list_categories covers shared categories for watchlist accounts, library posts, and assets. This provides clear routing guidance with no ambiguity.

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

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

Beyond the readOnlyHint annotation, the description discloses the default sort behavior, defines the virality semantics behind viral_only ('breakthrough posts that beat the org's virality threshold'), and adds a mandatory presentation behavior (include each post's permalink). No contradiction with the annotations; it adds genuinely useful behavioral context.

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

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

Three sentences with zero waste: the main purpose is front-loaded, followed by a parameter clarification, then a single-sentence presentation requirement. Every sentence earns its place, and the most decision-relevant information appears first.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 listing tool with a fully documented 8-parameter schema and a readOnlyHint annotation, the description covers default ordering, the special viral filter semantics, and the permalink presentation requirement. The only notable gap is that no output schema exists and the response structure beyond permalinks is unspecified — a minor omission for a list tool.

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

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

Schema description coverage is 100%, so the baseline of 3 applies — all 8 parameters are already documented in the schema. The description adds marginal value by defining viral_only as 'breakthrough posts' relative to the org's virality threshold, but it does not elaborate on sort, tags, account, category, or platform semantics beyond what the schema 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 and resource ('List the posts') plus a precise scope ('published by the org's own connected accounts (My Accounts)') and anchors the default ordering ('newest first by default'). The 'My Accounts' framing clearly distinguishes this tool from siblings like list_viral_posts and list_analyzed_posts without opening any schema.

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

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

The scope is clearly conveyed: this tool is for the org's own connected accounts, which implicitly separates it from global or analyzed-post listing siblings. It also provides post-call usage guidance ('always include each post's permalink'). It stops short of explicitly naming alternatives or when-not-to-use conditions, so it earns a 4 rather than 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?

The readOnlyHint annotation already communicates safety, and the description adds meaningful behavioral detail by enumerating returned fields: followers, average views, connection health, category, and tags. It also clarifies the account scope (official API connections) and the watchlist distinction, giving the agent a good sense of what to expect beyond the annotation.

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

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

The description is a single, well-structured sentence that front-loads the core purpose, then provides scoping context, output fields, and a key distinction. Every phrase earns its place, and there is no redundant restatement of the tool name or 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?

The tool is a straightforward list operation with no required parameters and a fully described input schema. The description covers what the tool lists, what fields are returned, and how it differs from the watchlist sibling. The absence of an output schema makes the listed output fields especially valuable, but pagination or result-limit behavior is not mentioned; that minor gap prevents a perfect score.

Complex tools with many parameters or behaviors need more documentation. 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 a clear explanation. The description does not add new parameter-level semantics; it only lists output fields, which is not required because the schema already carries the filtering guidance.

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

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

The description states a specific verb ('List') and a specific resource ('the organization's OWN connected accounts'), and clarifies the meaning of 'My Accounts' as official API-connected Instagram/TikTok accounts. It also explicitly distinguishes this tool from the watchlist, making it easy for an agent to know exactly what this tool 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 clearly positions this tool as the one for the organization's own accounts and explicitly says it is 'Distinct from the watchlist (competitors/inspiration)', which tells the agent when not to use it. This effectively routes the agent toward list_watchlist_accounts for competitor/inspiration data, even though that sibling is not named directly.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds useful context beyond that: the scope ('org's own connected accounts') and the multiplicity ('An account can carry several'), which helps the agent understand the data model. Minor gap: no mention of return format, but for a simple zero-parameter list that is not critical.

Agents need to know what a tool does to the 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 main purpose is front-loaded, and the clarifying distinction from list_tags is concise and placed at the end where it belongs. 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 zero-parameter read-only list tool, the description fully covers what is listed, the scope, the multiplicity, and how it differs from its nearest sibling. There is no output schema, but the return value (tags) is implicit and no additional context is needed 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 tool has zero parameters and schema coverage is 100% (vacuously). With no parameters, the description has no need to explain them; the baseline of 4 is appropriate because nothing is missing.

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

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

The description uses a specific verb ('List') and resource ('tags available on the org's own connected accounts (My Accounts)'), making the tool's purpose unambiguous. It also distinguishes itself from the sibling 'list_tags' by explicitly stating what that sibling covers, so an agent can tell them apart immediately.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 explicit routing guidance: 'Separate list from list_tags, whose text tags apply to library posts and assets.' This names the alternative tool and the condition that differentiates them, with no ambiguity left to inference.

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

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

Annotations already declare readOnlyHint=true, so the read-only nature is covered. The description adds useful context beyond annotations by specifying that notes are internal team notes and are organized as a thread, but it does not disclose ordering, pagination, or response format. This is acceptable given the annotation coverage, so a mid-range score is appropriate.

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

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

The description is a single sentence that front-loads the action and resource, then adds a brief parenthetical clarification. Every word earns its place, and 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 one-parameter, read-only list operation, the description is complete. It states what is listed, clarifies the nature of the notes, and the schema fully documents the only parameter. No output schema exists, but the return value (a note thread) is implied clearly enough.

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

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

Schema description coverage is 100%: post_id is described as 'Post id (UUID) from list_viral_posts / list_analyzed_posts.' The tool description itself adds no parameter-level meaning beyond the schema, 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 verb ('List') and resource ('the team's note thread on a post'), and clarifies the scope with 'internal notes exchanged in the app between team members about that post.' This clearly distinguishes it from sibling tools like add_post_note and get_post_analysis without needing to open 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 provides clear context for when to use the tool: when retrieving the team's internal note thread for a post. It does not explicitly name alternatives or state exclusions, but the phrasing makes the use case unmistakable, especially relative to add_post_note.

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

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

Annotations already mark this as read-only, and the description adds value by disclosing that tags are normalized (lowercase, hyphens for spaces) and that the result aggregates two sources. It does not cover ordering or pagination, but for a zero-parameter read operation this is acceptable.

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

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

The description is two sentences with no filler. The first sentence states the action and scope; the second adds the normalization rule. Everything earns its place.

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

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

Given zero parameters, a read-only annotation, and no output schema, the description provides enough context to invoke the tool correctly: scope, source union, and tag normalization. The only minor omission is an explicit statement of return shape, but 'list tags' sufficiently implies an array of strings.

Complex tools with many parameters or behaviors need more documentation. 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 is empty and there are zero parameters, so there is nothing for the description to add beyond the schema. Per baseline for zero-parameter tools, the score is 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 identifies a specific verb ('List') and resource ('all the organization's tags'), and defines the scope precisely as the union of the global tag registry and custom tags used on posts and assets. This clearly separates it from account-scoped siblings 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 conveys that this is the org-wide tag listing surface through phrases like 'all the organization's tags' and 'global tag registry.' It does not explicitly name sibling alternatives or state when not to use it, 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?

Annotations already declare readOnlyHint=true, and the description adds meaningful behavior beyond that: default sorting by recent, `since` overriding sort, oldest-first polling order, and the pagination stop condition. It does not describe the return shape, but for a read-only list tool the added behavioral detail is substantial.

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

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

The description is dense but well-structured: it opens with purpose, then covers sorting, polling, pagination, and downstream tool usage. Every sentence carries operational value, and there is no filler or repetition of schema fields.

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

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

For a read-only tool with no required parameters, the description covers the core operational contract: sorting, paging, polling state, and required post-presentation behavior. The absence of an output schema leaves some return-shape ambiguity, but the description is unusually explicit about the polling contract and follow-up tools.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by explaining the polling workflow with `since`, `offset`, `count`, and `next_since`, and reinforces that `sort` is ignored when `since` is set. This goes beyond simply restating the schema parameters.

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

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

The description names a specific verb and resource: lists viral posts detected on the user's watchlist, and defines 'viral' as Instagram Reels and TikTok videos that beat the account's baseline. This clearly distinguishes it from generic list tools like list_analyzed_posts or 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 explicit usage scenarios: polling with `since`, paginating with `offset` until `count < limit`, persisting `next_since`, and routing to get_post_preview and get_post_analysis. It does not explicitly contrast this tool with sibling list tools, but the usage context is strong and actionable.

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

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

The readOnlyHint annotation already signals a safe read operation, and the description adds useful behavioral context beyond that by specifying the scope ('watchlist') and the returned fields. It does not mention pagination or empty-result behavior, but for a simple read-only list tool the disclosure is sufficient.

Agents need to know what a tool does to the 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 delivers the purpose, scope, and returned fields with no wasted words. The key action and resource are front-loaded, making it easy for an agent to parse quickly.

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

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

For a tool with one optional parameter, read-only annotations, and no output schema, the description covers the essential facts: what is listed, for whom, and what fields are returned. It could be slightly more complete by explicitly noting the platform filter behavior or contrasting with list_my_accounts, but the schema fills most 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%, and the only parameter 'platform' is fully documented with an enum and a clear 'Filter by platform' description. The tool description does not add further parameter nuance, 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 ('List') and identifies the exact resource: Instagram and TikTok accounts in the user's watchlist. It also indicates the returned data (follower counts, last post date), which clearly distinguishes it from related tools like list_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 intended use is implied by the phrase 'user's watchlist' and the sibling tools add_watchlist_account/remove_watchlist_account, but the description does not explicitly state when to use this tool versus alternatives like list_my_accounts. 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?

With annotations declaring readOnlyHint=false and destructiveHint=false, the description's explicit note that 'out of any folder' removal is part of this tool's behavior adds useful nuance. It also implies the operation is non-destructive, aligning with the annotations, but does not detail failure modes or permissions.

Agents need to know what a tool does to the 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 front-load the purpose and immediately address the most common fatal ambiguity (moving out of a folder vs deleting). 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 mutation tool with rich annotations (idempotentHint=true, destructiveHint=false) and complete schema coverage, the description covers the essential behavioral nuance and sibling disambiguation. It could mention what happens when an assignment is moved over an existing folder, but this is not necessary 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?

Input schema coverage is 100%, with clear descriptions for folder, assignment_id, and assignment_ids. The description adds minimal value beyond the schema, though the phrase 'one or several assignments' reinforces the singular/plural parameter distinction.

Input schemas describe structure but not intent. Descriptions should explain 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 action verb ('Move') and a clear resource ('existing assignments') and destination ('folder'), explicitly noting the tool can also move assignments out of a folder. This differentiates it cleanly from sibling tools like assign_crew.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 the core use case (move into or out of a folder) and names the sibling tool to use for the adjacent task ('Attaching the crew... is a separate step: assign_crew'). This tells the agent when not to use this tool, which is strong guidance.

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

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

Annotations already indicate the operation is idempotent and non-destructive. The description goes beyond annotations by disclosing anti-cycle behavior, partial-success semantics ('those are reported as errors, the rest proceed'), and ownership behavior ('Creator owners are kept, dormant while nested'). This gives the agent valuable expectations beyond structured fields.

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

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

The description is compact and front-loaded with the primary purpose. Each sentence adds distinct useful information: batch scope, anti-cycle behavior, and ownership behavior. There is no filler or redundant 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 two-parameter tool with 100% schema description coverage and rich annotations, the description covers the essential behavioral nuances: batch semantics, root destination, cycle handling, partial failure, and ownership side effects. Nothing critical is missing 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 input schema already documents both parameters fully and even explains the 'root' special value for destination. The description reinforces that multiple folders are expected but adds little semantic detail beyond the schema, 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 verb ('Move'), a clear resource ('SEVERAL assignment folders'), and the target context ('under a new parent (or to the root) in ONE call'). It clearly differentiates itself from the singular sibling move_assignment_to_folder by emphasizing batch moving.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 tool is for batch moving multiple assignment folders in one operation, and it mentions the special destination 'root'. However, it does not explicitly name alternative tools like move_assignment_to_folder or state when to prefer one over the other, so some usage guidance is left to inference.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is covered. The description adds genuinely useful context beyond that: 'The video itself stays on the assignment' clarifies the blast radius of the destructive action, plus it names the source of the identifier (get_assignment).

Agents need to know what a tool does to the 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 scope, with no filler. The second sentence carries the non-obvious preservation guarantee.

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

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

For a two-parameter removal tool with full schema coverage and annotations supplying the destructive/idempotent profile, the description is nearly sufficient. It could note reversibility or required permissions, but nothing critical is missing for correct invocation.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema (including that dispatch_id comes from get_assignment). The description restates that origin but adds no new syntax or format detail beyond the schema, 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 gives a specific verb (cancel/remove) and resource (a dispatch = one send or one planned variation of an assignment). The scoping clause 'one send or one planned variation' implicitly distinguishes it from delete_assignment, though no sibling is named explicitly.

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

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

Usage is implied rather than stated: '(dispatch_id from get_assignment)' signals the workflow of first fetching an assignment, then removing a dispatch. There is no explicit when-to-use/when-not guidance and no mention of alternatives such as delete_assignment or dispatch_video.

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?

Although annotations already include destructiveHint=true, the description goes well beyond them by specifying the exact cascade: it 'permanently deletes the account AND all its detected viral posts (and any assignments pointing at them)' and adds the authorization requirement. This is valuable behavioral context the annotations do not provide.

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

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

Three sentences with no filler: the first states the action, the second flags destructiveness with exact consequences, and the third gives the safe alternative. Critical information is front-loaded and 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 destructive one-parameter tool with no output schema, the description is complete. It covers the action, permanent consequences, permission requirements, and an alternative safe path. Nothing needed to correctly select and invoke the 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 input schema has 100% description coverage for its single parameter, clearly documenting that 'account' accepts a username or account id from list_watchlist_accounts. The tool description adds no additional parameter meaning beyond referring to the account, 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 uses a specific verb and resource: 'Remove an Instagram account from the watchlist.' It clearly differentiates this tool from siblings like add_watchlist_account and list_watchlist_accounts, and the destructive detail further clarifies that this is a removal with serious consequences.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 who may use it ('Only the org owner or an admin'), the condition under which it is appropriate, and a when-not scenario: 'To stop tracking without losing data, remove it from the app instead after exporting what you need.' This gives the agent clear decision guidance.

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

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

Annotations already provide readOnlyHint=true and openWorldHint=false, so the safety and closed-world profile are known. The description adds useful scope context (organization asset library, content-production media types), but it does not disclose return ordering, result shape, or the empty-query behavior; those details live only in the schema. This is adequate but not rich behavioral disclosure.

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

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

One focused sentence front-loads the verb and resource, then adds the searchable fields and asset scope. Every phrase earns its place; the parenthetical is genuinely useful context rather than filler.

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

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

For a low-complexity, read-only search tool with two optional parameters fully covered by the schema and safe annotations, the definition is largely complete. Since there is no output schema, explicitly stating that the tool returns matching asset records would have been slightly more complete, but the tool name and 'Search' semantics make that inferable.

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

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

The input schema already documents both parameters with 100% coverage, including limits, defaults, and the empty-query behavior. The description's mention of name/description/tags aligns with the query parameter's documented free-text semantics, but it adds no syntax, formatting, or additional parameter meaning beyond what the schema 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 uses a specific verb ('Search'), a defined resource ('organization's asset library'), and concrete search dimensions ('by name, description or tags'), while clarifying the asset types as videos/images uploaded for content production. This clearly distinguishes it from sibling tools like get_asset_download_url or update_asset, which are different operations on the same domain.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 the search use case: an agent should call this tool when needing to find assets by metadata text, not download or modify them. However, it does not explicitly name alternatives or state when-not-to-use conditions (e.g., 'use get_asset_download_url to fetch a known asset'), so it stops short of a top score.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false, and readOnlyHint=false. The description adds the useful 'clear with none' behavior, but does not disclose side effects, permission requirements, or overwrite semantics. There is no contradiction with the annotations.

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

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

The description is a single, tight sentence with no filler. It front-loads the core action, then concisely adds the platform scope and clear 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 simple three-parameter mutation with full schema coverage and safety annotations, the description is nearly complete. It would be slightly stronger if it noted what happens on success or whether the category must already exist, but these are minor 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?

All three parameters have schema descriptions, giving 100% schema coverage. The tool description mostly repeats the platform scope and the 'none' clearing behavior already present in the schema, so it adds little new parameter-level meaning.

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

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

The description uses a specific verb ('Assign') and a specific resource ('watchlist account (Instagram or TikTok)'), and adds the clearing behavior ('or clear it with none'). This clearly differentiates it from sibling tools like set_my_account_category and set_post_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?

The 'watchlist account' qualifier gives clear context: this tool is for tracked watchlist accounts, not owned accounts or posts. However, it does not explicitly name alternatives or state when not to use it, leaving exclusion rules 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?

Beyond the annotations, the description discloses meaningful behavior: production-folder assignments and sub-folders inherit the link, assignment links take precedence, and only the creator's next uploads are routed to the Drive folder. It also clarifies the unlink behavior via 'none'. These side-effect semantics are valuable and not present in the structured data.

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

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

Two sentences deliver the core purpose, target options, inheritance rules, and unlink behavior with no filler. The most important information is front-loaded, and every clause adds meaning.

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

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

For a mutating tool with three parameters and no output schema, the description covers the main semantics: target selection, inheritance, precedence, and unlink. There is minor ambiguity about whether an unlink operation requires a target argument, but overall the definition provides enough context for an agent to use 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 input schema already covers all parameters at 100%, so the baseline is 3. The description adds value by explaining the one-target constraint, the relationship between assignment_id and production_folder, and the special 'none' unlink value, which goes beyond the schema's property-level descriptions.

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

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

The description opens with a specific action: link a Google Drive folder to one target, and clearly names the two target types (production folder or assignment). This differentiates it from sibling tools like create_drive_folder and list_drive_folders by focus and behavior.

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

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

The description gives clear usage context: the tool links folders to exactly one target and explains the distinction between production-folder and assignment targets, including precedence. It does not explicitly enumerate alternative tools, but no sibling directly overlaps with this link/unlink behavior, so the guidance is sufficient.

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

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

Beyond the annotations (idempotent, non-destructive), the description adds the meaningful invariant that an account holds at most one category and explains the 'none' clearing behavior. It could have explicitly stated that assigning a new category replaces the existing one, but the constraint largely conveys this.

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

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

Two tight sentences front-load the action and resource, then add the clearing mode and the category lookup reference. 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 simple setter with full schema coverage and no output schema, the description supplies the core domain context: target accounts, category source, single-category invariant, and clearing option. It leaves the sibling distinction and replace-vs-overwrite semantics implicit, which are the only noticeable 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%, so the account, category, and platform parameters are already documented. The description mostly restates the 'none' behavior from the schema, adding only the My Accounts context rather than new parameter-level meaning.

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

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

The description names a specific action ('Assign a category') and resource ('org's own connected accounts (My Accounts)'), and adds the clearing behavior with 'none'. It does not explicitly contrast with the sibling set_account_category, so it falls just short of full sibling differentiation.

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

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

The description makes clear the target scope (My Accounts) and points to list_my_account_categories as the source of valid categories, which gives context for use. It does not specify when not to use this tool or compare it to set_account_category, so the guidance is only implicit.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=true, so the agent knows this is a mutating but idempotent operation. The description adds the behavioral detail that 'none' clears the category, which is valuable. However, it doesn't disclose details like whether assignment overwrites existing categories, whether 'none' is case-sensitive, or whether partial failures occur when multiple post_ids are provided. With annotations covering the mutation profile, a 3 is appropriate.

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

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

Single sentence that is clear and front-loaded with the verb and object, followed by the essential 'none' clarification. No wasted words, no repetition of schema details. It earns its place.

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

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

For a simple idempotent assignment tool with full schema coverage and no output schema, the description is quite complete. It covers the two key behaviors (assign and clear). A minor gap is not mentioning the relationship to category existence — whether 'category' must already exist or if it can be created on the fly — and whether the assignment replaces an existing category. But given the tool's simplicity and annotations, this is adequate.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema: post_ids as an array of UUIDs (1-50 items) and category as a string or 'none'. The description adds minimal value beyond the schema, just clarifying that 'none' clears the category and that posts are Instagram/TikTok posts. Baseline 3 is correct since the schema handles parameter semantics.

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

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

The description states the specific verb 'Assign' or 'clear', the resource (library posts of Instagram or TikTok), and the action scope (one or more). It explicitly mentions the 'none' value for clearing, which clearly distinguishes it from sibling tools like set_account_category or update_folder. This is a precise, unambiguous statement of 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?

The description clearly conveys the tool's purpose for assigning or clearing categories on posts, and the 'none' value explicitly covers the clearing use case. While it doesn't explicitly name alternative tools or exclusion conditions, the purpose is specific enough that an agent can infer when to use it. It does not explicitly say when not to use it versus set_my_account_category or create_category, but the context is clear.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context: the favorite star is shared with the app and feeds list_viral_posts favorites_only, which is not obvious from annotations or 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 a single, tightly written sentence that front-loads the action and resource. The parenthetical adds cross-tool context without wasting words.

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

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

For a simple two-parameter mutation with idempotent behavior already declared by annotations, the description is largely complete. It could add a bit more about response behavior, but the absence of an output schema and the simplicity of the operation keep the gap minor.

Complex tools with many parameters or behaviors need more documentation. 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 post_ids and favorite clearly documented in the input schema. The description adds no additional parameter-level detail beyond restating the binary favorite action, 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 pair, "Mark or unmark," with a clear resource, "library posts as favorites," and clarifies the action's connection to the app's star feature. It is immediately distinguishable from all sibling tools, none of which cover favoriting 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?

The description provides clear context by linking the favorite state to list_viral_posts favorites_only filtering, which helps an agent understand the downstream effect of using this tool. It does not explicitly state when not to use it or name alternative tools, but the reference to the sibling list tool is enough to orient the agent.

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

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

The annotations already declare readOnlyHint=true, so no safety contradiction. The description adds valuable behavioral detail beyond that: accounts can carry multiple tags and therefore appear in multiple groups with counts that do not add to the total, and include_views is tied to reading each account's latest stats snapshot with a performance tradeoff for large rosters. This is exactly the kind of non-obvious behavior an agent needs.

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

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

Three sentences with no filler: the core capability, the canonical use case, and the most important caveat (non-additive group counts) all appear up front. Every sentence earns its place.

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

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

With no output schema, the description carries the burden of explaining the return value, and it does: counts per group, connection-status breakdown, and aggregated metrics including followers, average views, breakthrough posts, and 24h/7d views. It also covers the toggle for listing individual accounts and the multi-tag caveat, making it complete for a 7-parameter read-only aggregation tool.

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

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

Schema description coverage is 100%, so the input schema already documents every parameter's meaning and default. The description adds useful context about tag overlap causing duplicate grouping, but it does not materially extend the per-parameter semantics beyond what the schema provides. 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 uses a specific verb ('Roll up') with a clear resource ('the org's own connected accounts (My Accounts)') and the exact grouping dimensions ('by tag, category or platform'). It also gives the canonical use-case query, 'how are the accounts tagged X doing', which distinguishes it from list_my_accounts and get_my_account_stats.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 identifies the tool as 'the tool to answer...' a specific class of aggregation questions, giving clear context for when it is appropriate. It does not explicitly name alternatives or state when not to use it, but the use-case framing is strong enough to guide selection among the many sibling tools.

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

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

Annotations already convey readOnly=false, idempotent=true, and destructive=false, so the description only needed to add context on top. It adds the return behavior ('Returns the resulting set of tags') and the scope boundary that no tag is ever created, which are genuinely useful behavioral details beyond the annotations. It doesn't cover error behavior for nonexistent tags, but the precondition largely mitigates that 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?

Three tightly packed sentences, front-loaded with the core action ('Add and/or remove tags'), followed by the precondition and the return value. No filler, no repetition of schema content, and 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?

For a 4-parameter mutating tool with 100% schema coverage, no output schema, and safety conveyed by annotations, the description covers the essentials: what it operates on, the precondition, and what it returns. The only notable omission is explicit behavior on partial failure (e.g., one provided tag doesn't exist), which is a minor gap given the 'must already exist' precondition.

Complex tools with many parameters or behaviors need more documentation. 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 (account, add_tags, remove_tags, platform) is already fully documented with source references and disambiguation logic. Per the baseline rule, the description need not repeat parameter detail; it adds only marginal reinforcement about the pre-existence requirement for tags.

Input schemas describe structure but not intent. Descriptions should explain 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-resource pair ('Add and/or remove tags on one of the org's own connected accounts'), and scopes it to My Accounts, which distinguishes it from post-tagging tools like tag_posts. It also draws a boundary against tag creation ('this tool never creates one'), so an agent can tell it apart from any creation-oriented sibling without opening 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 clear precondition ('Tags must already exist in list_my_account_tags: this tool never creates one'), telling the agent when this tool is invalid for the task and pointing to the source of valid tag values. It stops short of a 5 because it never names the alternative tool to use when tags need to be created, and no create-tag sibling is visible in the list.

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

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

Beyond annotations, the description discloses important behavioral traits: tags are normalized (lowercase, spaces to hyphens) and new tags are registered globally so they appear in app filters. This adds real side-effect context beyond the readOnly/idempotent/destructive hints.

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

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

Two sentences with no filler. The core action is front-loaded, and every clause adds useful information about what happens to the tags and where they appear.

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

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

For a simple tool with one required parameter and no output schema, the description covers the operation, resource, and notable side effects. It could mention what the response contains, but that is not essential 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 coverage is 100%, so the schema already documents post_ids, add_tags, and remove_tags. The description adds general tag behavior (normalization, global registration) but no extra per-parameter meaning beyond what the schema 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?

Uses a specific verb phrase 'Add and/or remove custom tags' against a clear resource ('posts of the library (Instagram or TikTok)'). It distinguishes from sibling tools like tag_my_account and delete_tag, and adds concrete behavioral details about normalization and global registration.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 resource scope and tag behavior imply when this tool is appropriate, but nothing explicitly tells an agent when to choose it over alternatives such as tag_my_account or delete_tag. The usage context is clear but not formally stated.

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

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

Beyond the annotations, the description adds genuine behavioral context: multiple operations can be combined in one call, and the '@model' tag is protected. It does not contradict the annotations, and it appropriately warns about a constraint that annotations cannot express.

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

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

Three short, front-loaded sentences cover the main purpose, the multi-operation behavior, and a key constraint. There is no filler or repetition of schema details.

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

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

The description, fully documented schema, and annotations together provide enough for correct invocation: operations, combinability, clear/unchanged semantics, and the protected system tag. The only minor gaps are the lack of explicit return behavior and no direct guidance on when not to use this tool relative to siblings.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds parameter-relevant meaning: it explains that operations can be combined and warns that '@model' cannot be passed for tag edits. This goes beyond the raw schema and helps an agent avoid a common failure.

Input schemas describe structure but not intent. Descriptions should explain 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 concrete verb and resource ('Update an asset of the library') and enumerates the supported operations: rename, set internal notes, assign a category, and add/remove custom tags. This is specific enough to distinguish it from the many sibling update_* and tag-related tools without needing 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 clearly scopes what the tool is for by listing asset fields it can modify, and it adds an important exclusion: the '@model' tag is system-managed and cannot be edited. However, it does not explicitly say when to prefer this tool over alternatives such as tag_posts, set_post_category, or update_category, so usage context is implied rather than stated.

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

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

Beyond the annotations (readOnlyHint false, idempotentHint true, destructiveHint false), the description adds valuable behavioral context: approving/refusing triggers a push notification, requires a submitted video, and 'sent' is restricted. This meaningfully discloses side effects and prerequisites.

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

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

Two tight sentences, with the core purpose and field list front-loaded, followed by the critical behavioral caveats. No wasted words or repetition of the schema.

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

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

The description covers all field categories and important constraints, and there is no output schema demanding return-value explanation. However, the contradictory statement about 'sent' leaves an agent with conflicting instructions, preventing a perfect completeness score.

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

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

Schema description coverage is 100%, so baseline is 3, but the description introduces a direct conflict: it says 'sent' cannot be set here while the schema's status enum explicitly includes 'sent'. This makes the status semantics unreliable for an agent despite the otherwise clear field grouping. The contradiction lowers the value of the description's parameter guidance.

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

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

The description opens with a specific verb and resource—'Update an assignment'—and immediately enumerates the mutable aspects: production status, due date, note/brief, and tags. This clearly distinguishes the tool from siblings like create_assignment and delete_assignment.

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

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

The description gives explicit conditions for approving/refusing (requires a submitted video) and a clear when-not: 'sent' cannot be set here. It does not name alternative tools explicitly, but the when/when-not guidance is strong enough to guide correct invocation.

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

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

Annotations already establish that this is a non-read-only, idempotent, non-destructive mutation. The description adds a meaningful behavioral constraint by restricting use to owners/admins, which is not present in the annotations.

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

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

Two short sentences with no filler. The action is front-loaded and the permission constraint follows directly.

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

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

For a simple 3-parameter update with full schema coverage and annotations, the description is sufficient to invoke correctly. It could name a return value, but no output schema exists and the operation is straightforward.

Complex tools with many parameters or behaviors need more documentation. 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%; each parameter has a description with semantics like 'Empty = unchanged.' The description itself only summarizes the two updateable fields and adds no new detail 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 names a specific verb and resource ('Rename a category and/or change its color') and clearly distinguishes this from sibling tools like create_category and delete_category. The permission caveat adds clarity about who may invoke it.

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

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

It establishes a clear use case (renaming or recoloring an existing category) and states an authorization requirement (Owner or admin only). It does not explicitly name alternatives or exclusions, but the context is unambiguous given the sibling set.

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

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

Annotations already mark this as readOnly=false, idempotent=true, and destructive=false. The description adds valuable behavioral context beyond those hints: subtree cascading for archive/unarchive, ancestor restoration on unarchive, and preservation of assignment links during rename. There is no contradiction with the annotations.

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

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

The description is three sentences with no filler. It front-loads the most important constraint (one operation per call), then lists the supported operations, and ends with a specific warning that prevents a common misuse. 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 5-parameter mutation tool with a complete schema and useful annotations, the description covers the key edge behaviors: cascade scope, ancestor restoration, link preservation, and the single-operation limit. No aspect needed to call the tool correctly is missing, and the absence of an output schema is not a gap 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 each parameter. The description adds important operational semantics not present in the schema, such as 'ONE operation per call', cascade behavior for archive, ancestor restoration on unarchive, and the rename safety guarantee. This elevates it above the baseline 3.

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

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

The description clearly identifies the tool as updating an assignment folder and enumerates the exact supported operations: rename, move, archive/unarchive, and change owner. This distinguishes it from siblings like archive_folder, move_folders, and delete_folder by spelling out the resource and the operation 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 concrete usage guidance: one operation per call, archive cascades, unarchive restores ancestors, and renaming preserves links rather than deleting and recreating. It does not explicitly compare against sibling tools like archive_folder or move_folders, but the operatation list plus the 'never delete and recreate' warning gives an agent enough context to choose appropriately.

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