linkedmash

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

With no annotations, the description must reveal behavior. It explains the pagination pitfall (labeling only one page) and that label_name will create if missing. However, it doesn't mention idempotency, rate limits, or return value. Still, it covers the most critical behavioral aspects.

Agents need to know what a tool does to the 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: first states the purpose, second provides a critical warning and alternative. Every sentence is necessary and informative. Front-loaded with core action.

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

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

For a tool with 3 fully documented parameters and no output schema, the description is complete. It covers purpose, usage boundary, parameter selection, and common pitfalls. No gaps remain for an agent to misuse the tool.

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

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

Despite 100% schema coverage, the description adds context: post_ids must be a small, explicitly chosen set; either label_id or label_name is required; label_name creates if nonexistent. This clarifies intent and constraints 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 action: 'Add a label to a FEW explicitly chosen posts'. It specifies the resource (labels) and scope (specific post_ids), and implicitly distinguishes from sibling tool 'tag_bookmarks_by_filter' by emphasizing 'FEW' vs 'all'.

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

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

Explicitly tells when NOT to use: 'NEVER use this to label all posts matching a filter'. Names alternative: 'use tag_bookmarks_by_filter instead'. Provides clear context for correct usage.

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

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

Discloses reversibility and truncation behavior, but without annotations, it lacks details on rate limits or the exact cap value. Adequate but not comprehensive.

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

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

Concise yet comprehensive, with clear step-by-step instructions and zero redundant information. Every sentence adds value.

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

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

Covers the core workflow, return values, and confirmation protocol. Missing output schema details but partially compensated by detailed description of what to report.

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

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

Adds meaningful context beyond schema for key parameters like confirm, is_unread_only, and hide_archived, clarifying usage constraints and defaults.

Input schemas describe structure but not intent. Descriptions should explain 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 specifies the action ('ARCHIVE'), resource ('bookmarks'), and scope ('matching a filter in ONE server-side call'), distinguishing it from siblings like delete_bookmarks_by_filter.

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

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

Explicitly instructs to call get_bookmark_count first and get user confirmation, and notes the reversible nature. Could be improved by stating when not to use this tool vs. deleting.

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

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

No annotations are provided, so the description carries the full burden. It discloses the paid plan requirement and implies cancellation is destructive. However, it does not describe return values or error states.

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

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

The description is extremely concise with two sentences, no wasted words, and the key information is front-loaded. It is efficiently 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 simple one-parameter tool with no output schema, the description covers the essential aspects: what it does, the parameter source, and a prerequisite. It could be more complete by mentioning success/failure outcomes, but it is sufficient for the tool's complexity.

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

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

The schema already provides a clear description for the single parameter (schedule_id). The tool description adds no extra information beyond referencing its source (get_queue). With 100% schema coverage, baseline score of 3 is appropriate.

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

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

The description clearly states the action (cancel), the resource (scheduled post), and the required identifier (schedule id from get_queue). This distinguishes it from sibling tools like schedule_post and get_queue.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 when to use (to cancel a scheduled post) and mentions a prerequisite (paid plan). It could be improved by noting when not to use or suggesting alternatives, but the context from sibling tools provides clarity.

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

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

No annotations are provided, so the description carriers full burden. It states the tool creates a draft and returns its id, but does not disclose any behavioral traits such as rate limits, maximum content length, or what happens if required parameters are missing (though schema covers required).

Agents need to know what a tool does to the 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, front-loaded with the main purpose, and every sentence provides useful information without redundancy.

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

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

Given 7 parameters with full schema coverage and no output schema, the description covers the basic flow (create, return draft id, plan requirement) and mentions future scheduling/publishing. Missing error scenarios or integration with sibling tools like upload_media, but adequate for typical use.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds minor value by specifying 'put the post body text in 'content'', but schema already describes 'content' as the body text. No additional meaning is added for other parameters.

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

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

The description clearly states 'Create a new LinkedIn post draft' with specific verb and resource, and distinguishes from siblings like schedule_post and update_draft by mentioning it returns a draft with id that can later be scheduled or published.

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

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

The description mentions the paid plan requirement and that the draft can be scheduled later, providing usage context. However, it lacks explicit guidance on when not to use this tool vs alternatives like schedule_post or update_draft.

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

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

With no annotations, the description carries the full burden. It discloses the return value (created folder with slug) and parameter effects, but does not mention authentication needs, rate limits, or any potential side effects beyond creation.

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

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

Two concise sentences with no wasted words. The key information (purpose, required parameter, optional parameters, return value) is front-loaded and clearly 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?

Despite no output schema, the description explains the return value. Parameter explanations are sufficient given the tool's moderate complexity. It covers the essential aspects without leaving major gaps.

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

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

Schema coverage is 100%, so each parameter has a schema description. The description adds contextual meaning (e.g., 'saved filter/workflow', 'tabs/stages') and mentions the return includes slug. This adds modest value beyond the schema.

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

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

Description clearly states 'Create a smart folder (filtered view)' — a specific verb and resource. It distinguishes from siblings like get_smart_folder, update_smart_folder, and delete_smart_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 usage by explaining the purpose of parameters, but does not explicitly state when to use this tool versus alternatives like update_smart_folder or when not to use it. No exclusions or context are provided.

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

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

No annotations provided, so description carries full burden. It discloses soft deletion but treats as destructive, return values (matched/affected counts), and truncation behavior. Could mention rate limits or authentication.

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

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

Description is thorough but somewhat long; however, every sentence adds value. Front-loaded with purpose and immediate usage rules. Could be slightly more concise without losing essential 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?

No output schema, but description explains return values and truncation behavior. For a destructive tool with 12 parameters, it covers preview, consent, and post-call reporting. Complete for most scenarios.

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

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

Schema coverage is 100%, but description adds crucial context: confirm parameter must only be true after user confirmation, hide_archived defaults true, is_unread_only omitted unless user asks. Enhances usability.

Input schemas describe structure but not intent. Descriptions should explain 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 'DELETE all bookmarks matching a filter in ONE server-side call,' specifying the verb and resource. It distinguishes from siblings like archive_bookmarks_by_filter by emphasizing destructive deletion.

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

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

Provides explicit step-by-step guidance: tell user what will be deleted using get_bookmark_count, get explicit consent, then call with confirm=true. Also advises on handling 'truncated' responses.

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

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

No annotations are provided, so the description carries the full burden. It describes the action as 'move to trash', implying non-permanent deletion, and states the plan requirement. This is largely transparent but could mention if the action is reversible.

Agents need to know what a tool does to the 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 covering action, resource, and requirement. No wasted words, front-loaded with the key action.

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

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

For a simple tool with one required parameter and no output schema, the description is fully self-contained and provides all necessary information 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 parameter is well-documented in the schema. The description reinforces that the id is used but adds no new meaning beyond the schema's description.

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

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

The description clearly states the action ('Delete (move to trash)') and the resource ('a Content Studio draft by its id'), differentiating it from sibling tools like 'cancel_scheduled_post' or 'forget'.

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

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

The description provides clear context on what the tool does but does not explicitly mention when not to use it or list alternatives. It does include a requirement (paid plan), which is helpful.

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

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

Despite no annotations, the description clearly discloses the destructive nature (removes the saved filter/workflow) and explicitly states what is not destroyed (no saved posts). This is comprehensive for a simple delete operation.

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

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

The description consists of two concise sentences with no filler. The key action and scope are front-loaded, and every sentence contributes essential information.

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

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

For a tool with one required parameter, no output schema, and no nested objects, the description fully covers purpose, usage, prerequisites, and behavioral boundaries. No additional context is needed.

Complex tools with many parameters or behaviors need more documentation. 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 'slug' is described in the input schema, and the tool description reinforces that it is obtained from list_smart_folders. The description adds value by providing the source of the slug, slightly augmenting the schema's description.

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

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

The description clearly states the action ('Delete') and the resource ('smart folder (filtered view)') with the identifier ('by its slug'). It distinguishes the tool from siblings like create_smart_folder and update_smart_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 tells when to use this tool (to delete a smart folder), what it does NOT affect ('does NOT delete any saved posts'), and how to obtain the required slug ('Use list_smart_folders to find the slug'). This prevents misuse and guides 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?

No annotations provided, so description carries full burden. It discloses destructive action and optional scoping. Could mention behavior when key doesn't exist, but overall clear.

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

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

Two sentences, front-loaded with main action, no unnecessary words. Efficient and clear.

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

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

Tool is simple with 2 params; description covers usage and parameters. No output schema, but deletion tools often don't need return value explanation. Slightly lacking in error handling context.

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

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

Schema coverage is 100%, but description adds value by clarifying that key removes all memories with that key, and kind restricts deletion with advice on 'none' 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?

Description clearly states action (delete), resource (durable user memory), and scope (by key, optionally kind). It also distinguishes from sibling tool 'remember' by mentioning re-adding after correction.

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

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

Provides explicit scenarios: when user asks to forget something or correct outdated info before re-adding. Lacks explicit 'when not to use' but 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?

No annotations are provided, so the description carries full burden. It correctly implies this is a read-only operation (fetching analytics). However, it does not disclose any behavioral traits like rate limits, data freshness, or whether multiple calls are needed for different time windows. Adequate but not rich.

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

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

The description is a single sentence that is well-structured and front-loaded with the action and resource. Every part adds value, with no unnecessary words. Highly concise.

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

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

Given the tool's simplicity (one optional parameter, no output schema, no nested objects), the description provides sufficient context: the type of data returned (specific metrics), the time window parameter, and a prerequisite (paid plan). It is complete for effective tool usage.

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

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

Schema coverage is 100% and the description reiterates the parameter meaning and examples ('7d', '30d', '90d') already present in the schema. No additional context beyond the schema is added, so 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 'Get' and identifies the resource as 'user's account-level LinkedIn analytics', listing the exact metrics (impressions, reactions, etc.) and the time window parameter. This clearly distinguishes it from sibling tools like get_post_analytics (post-level) and get_growth_digest (different 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 states the tool's purpose and a prerequisite (paid Creator/Lifetime plan), but does not explicitly guide when to use this over siblings or when not to use it. For instance, it doesn't mention that get_post_analytics is for individual posts, which would help with tool selection.

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

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

No annotations present; description notes it's a read operation ('get') and specifies returned data. Lacks details on authorization, rate limits, or error conditions, but adequate for a simple retrieval tool.

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

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

Two sentences, no redundancy, concise and front-loaded with the core action and use case.

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

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

Adequately covers purpose, parameter, and return value. No output schema, so the description provides necessary return information. Missing trivial details like 'returns a single object' but sufficient for a simple get tool.

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

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

Schema coverage is 100%. Description adds value by specifying what fields are returned (full content, author, media, tags) beyond the schema's parameter description.

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

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

Description clearly states the tool gets a single LinkedIn bookmark by post_id and lists returned fields (full content, author, media, tags). Differentiates from siblings like list_bookmarks and search_bookmarks.

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

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

Explicitly states use case: 'to read one specific saved post, e.g. before creating content based on it.' Provides clear context but doesn't explicitly exclude 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?

With no annotations provided, the description carries full disclosure burden. It explains that counts respect all filters, defaults match list_bookmarks, and the result echoes applied_filters. It does not mention performance or side effects, but as a read-only count, this is acceptable. More detail on return format would improve transparency.

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

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

The description is four sentences, front-loading the purpose and then efficiently covering filter compatibility, defaults, and usage advice. No extraneous words; every sentence adds value.

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

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

Given 10 parameters, no output schema, and no annotations, the description provides sufficient context: filter consistency with list_bookmarks, default behavior, and advice to verify applied_filters. It equips the agent to use the tool correctly without needing additional information.

Complex tools with many parameters or behaviors need more documentation. 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 overarching context about filter consistency and defaults but does not add new meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool gets the count of bookmarks matching filters, distinguishing it from list_bookmarks which returns the actual bookmarks. The verb 'Get' and resource 'count of bookmarks' are specific and unambiguous.

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

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

The description explains the tool supports the same filters as list_bookmarks and specifies default behaviors (read+unread included, archived excluded). It advises checking applied_filters. However, it does not explicitly state when to use this tool versus list_bookmarks, which would improve distinguishability.

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

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

No annotations are provided, and the description only adds a plan requirement. It does not disclose return behavior, error handling, or other side effects of 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?

The description is two sentences with no wasted words. It is front-loaded with the core purpose.

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

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

For a simple get-by-id tool with one parameter and no output schema, the description provides sufficient context including a prerequisite, though it could mention error handling or return 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?

Schema coverage is 100%, and the description adds no further meaning beyond restating that the tool uses an id. Baseline 3 is appropriate.

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

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

The description clearly states it retrieves a single post/draft by its id, using a specific verb and resource. This distinguishes it from sibling tools like list_drafts.

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

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

The description mentions a prerequisite (paid plan) but does not explicitly state when to use this tool versus alternatives or provide 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?

No annotations are provided, so the description carries full burden. It discloses the return content (ranked actions, draft prompts, weekly numbers) and the paid plan requirement. However, it doesn't explicitly state whether the tool is read-only or idempotent, though the context implies it is a safe query.

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

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

The description is concise, using three sentences to cover purpose, usage guidance, and prerequisite. Each sentence adds value, and the most important information (what the tool returns) 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 read-only data retrieval tool with no parameters and no output schema, the description adequately explains the return value and when to use it. It could elaborate on whether the digest is real-time or cached, but it meets the essential needs.

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

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

With zero parameters, the schema coverage is 100% and nothing needs to be explained. According to guidelines, baseline is 4, and the description appropriately adds no extraneous parameter information.

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

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

The description clearly states the tool returns the user's GROWTH DIGEST, listing specific components like positioning, content pillars, authority gaps, and next-step actions. This distinctively differentiates it from sibling tools, which focus on bookmarks, drafts, analytics, or scheduling.

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

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

Explicit instructions are given: 'USE THIS whenever the user asks what they should post/do next, wants a growth plan or weekly review, or asks how to build authority.' It also mentions the prerequisite of a paid plan, providing clear context for when to invoke this tool.

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

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

No annotations provided, so description carries burden. Mentions required plan, but lacks details on data freshness, rate limits, or side effects. Read-only nature is implied but not explicit.

Agents need to know what a tool does to the 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-loaded with core functionality. No fluff.

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

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

Adequate for a simple tool with two optional params and no output schema. Could mention return format, but not required.

Complex tools with many parameters or behaviors need more documentation. 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 covers both parameters with descriptions. The description adds minimal context beyond schema (e.g., 'time window' without format). Baseline 3 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?

Description specifies 'Get per-post LinkedIn analytics' with concrete metrics (impressions, engagements, etc.) and time window. Differentiates from sibling 'get_analytics' by focusing on per-post and recently published.

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

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

Explicit prerequisite requiring a paid plan. Does not mention alternatives or when not to use, but the purpose is clear enough for agent selection.

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

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

No annotations are provided, so the description carries full burden. It indicates the tool retrieves data (a getter), implying a read-only operation, but does not explicitly state that it has no side effects or destructive potential. The requirement for a paid plan is noted, but other behavioral traits (e.g., auth scope, rate limits) are absent.

Agents need to know what a tool does to the 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. The core purpose is front-loaded in the first sentence, and the requirement is added succinctly. 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?

Given the tool's low complexity (no parameters, no output schema), the description covers the essential information: what the tool does and a critical prerequisite. However, it does not describe the return format or confirm that the tool is read-only, which would improve completeness slightly.

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

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

There are zero parameters, and the schema coverage is trivially 100%. The description does not need to add parameter details, and a baseline score of 4 is appropriate given the absence of 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?

Description clearly states the verb 'Get' and the resource 'recurring posting schedule' with specific details about the weekly time-slot grid and timezone. It effectively distinguishes the tool's purpose from siblings like get_posting_slots or set_posting_schedule.

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

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

The description mentions the requirement for a paid Creator/Lifetime plan, which provides a prerequisite but does not offer guidance on when to use this tool versus related tools such as get_posting_slots or set_posting_schedule. It lacks explicit when-to-use or when-not-to-use advice.

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

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

No annotations provided, so description carries full burden. Describes that it returns free slots and requires a paid plan, but does not disclose whether the operation is read-only or if slots are consumed. Minimal behavioral context beyond purpose.

Agents need to know what a tool does to the 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: first sentence defines purpose, second gives usage hint and prerequisite. No redundancy or filler. Front-loaded with key 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 tool with 2 parameters, no output schema, and no annotations, the description adequately explains what the tool returns and how to use the result. Missing explicit description of slot structure (e.g., format of timestamp), but still functional.

Complex tools with many parameters or behaviors need more documentation. 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. Description adds little beyond the schema: it contextualizes timezone by mentioning 'in their timezone', but does not elaborate on parameter formats or constraints.

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

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

Description uses specific verb 'Get' and resource 'free posting slots from the user's recurring posting schedule', distinguishing it from sibling tools like get_posting_schedule which returns the schedule itself. Also clarifies the timezone 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?

Explicitly states when to use the output ('Use a returned slot's timestamp as publish_at when scheduling') and mentions a prerequisite ('Requires a paid Creator/Lifetime plan'). However, no explicit when-not or comparison to 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?

With no annotations, the description carries full burden. It discloses grouping by date, optional filtering, and plan requirement, but omits potential pagination, empty queue behavior, and response format details beyond mentioning schedule id.

Agents need to know what a tool does to the 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 efficiently convey purpose, features, prerequisite, and usage hint. No unnecessary words, and key 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 one optional parameter and no output schema, the description covers listing, grouping, filtering, and schedule id usage. It lacks detail on output structure for empty queues or pagination, but remains largely complete 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?

The sole parameter 'status' is fully described in the schema (100% coverage). The description adds valuable guidance by suggesting 'none' or omission for the whole queue, which clarifies the enum behavior 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 the user's posting queue of scheduled and published LinkedIn posts, grouped by date, with optional status filtering. It specifies the inclusion of schedule ids for cancellation/rescheduling, distinguishing it from sibling tools like schedule_post and cancel_scheduled_post.

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

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

The description mentions a prerequisite (paid plan) and indicates the schedule id can be used with cancel/reschedule tools. However, it does not explicitly exclude alternatives or provide when-not-to-use guidance, such as when to use get_posting_schedule instead.

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

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

No annotations provided, so description carries full burden. It implies a read-only operation ('get'), but does not explicitly state non-destructiveness or authorization needs. However, for a simple read tool, the implicit behavior is clear.

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

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

Two sentences, each with a clear purpose. The first sentence defines the action and output, the second provides usage guidance. No unnecessary words.

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

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

Given the tool's simplicity (single parameter, no output schema, no nested objects), the description fully covers purpose, usage flow, and parameter semantics. It is complete for an AI agent to use correctly.

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

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

Schema coverage is 100% with a description for the slug parameter. The tool description adds value by explaining the slug's role and directing the user to obtain it from list_smart_folders, going beyond the schema's minimal description.

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

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

The description clearly states the tool retrieves one smart folder by its slug and lists the specific properties returned (name, description, filter query, tabs). It also distinguishes from sibling tools by naming list_smart_folders and get_smart_folder_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?

Explicit guidance: use list_smart_folders first to find the slug, and to read posts use get_smart_folder_posts. This provides clear context for when to use this tool versus 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?

No annotations are provided, so the description carries full burden. It discloses that the operation is a read (list), explains optional filtering by bucket, and describes pagination mechanism. However, it does not mention any potential side effects, authentication requirements, or rate limits, which would be useful for full transparency.

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

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

The description is brief yet comprehensive, consisting of three sentences that efficiently convey the tool's purpose, required input, and optional parameters. No unnecessary words.

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

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

Given the tool's complexity (4 parameters, no output schema, no annotations), the description provides all necessary information: purpose, parameter details, and usage instructions. It is complete for an agent to correctly select and invoke 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?

All parameters are fully described in the input schema (100% coverage). The description adds meaningful context beyond the schema: it explains that slug comes from list_smart_folders, bucket refers to a tab/stage, and cursor is a numeric offset. This helps the agent understand the parameters' roles.

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

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

The description clearly states the tool's purpose: 'List the saved LinkedIn posts inside a smart folder (filtered view).' It uses a specific verb ('list') and resource ('saved LinkedIn posts inside a smart folder'), distinguishing it from siblings like list_smart_folders or list_bookmarks.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 usage guidance: it explains that the slug comes from list_smart_folders, and how to optionally filter by bucket or paginate with cursor and limit. It does not explicitly state when not to use, but the instructions are clear enough for 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?

No annotations are provided, so the description carries full burden. It discloses key behavioral traits: defaults for unread and archived filters, that author supports fuzzy matching, and that users should not add filters unprompted. It does not discuss permissions or rate limits, but covers functional behavior well.

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

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

The description is detailed but well-structured, with the core purpose and important usage notes upfront. Each sentence provides necessary information without redundancy. It could be slightly more concise, but the structure aids readability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 (13 parameters, many with default behaviors) and no output schema, the description covers the essential usage context comprehensively. It explains parameter interactions and lists edge cases. A brief note on return format or pagination mechanics would make it complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds valuable context beyond the schema for many parameters, e.g., explanation of author fuzzy matching, default behaviors for is_unread_only and hide_archived, and instructions for when to omit or set specific values. This adds meaningful semantic guidance.

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

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

The description clearly states 'List bookmarks with optional filtering and pagination,' specifying the verb and resource. It explicitly outlines filtering options and distinguishes use cases like author filtering, making the purpose unambiguous.

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

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

The description provides explicit guidance on when to use parameters: e.g., 'Use this tool (with the 'author' parameter) when the user asks to show posts by a specific author' and instructs to apply only filters the user asked for. It also clarifies defaults and when to override them.

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

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

No annotations are provided, so the description carries the full burden. It discloses that this is a read-only listing tool filtering by status and requiring a paid plan. However, it does not mention pagination, sorting, or response format, which are common behavioral aspects for a list tool. The description is adequate but not thorough.

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

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

The description is concise, consisting of two sentences that efficiently convey the tool's purpose and a key requirement. It is front-loaded with the main action and avoids unnecessary detail.

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

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

Given the tool has one optional parameter and no output schema, the description covers the essential purpose and filter option. However, it lacks details on pagination, result count, or default behavior when multiple statuses are returned. Considering sibling tools and the simplicity of the tool, it is moderately complete but could be enhanced.

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

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

The input schema has 100% coverage for the single 'status' parameter, fully describing its enum values and the behavior of 'none'. The description adds 'Optionally filter by status' but does not provide new semantic information beyond what the schema already specifies. Thus, a baseline score of 3 is appropriate.

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

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

The description clearly states it lists the user's Content Studio posts including drafts, scheduled, and published, with an optional status filter. It specifies that these are posts the user is authoring, distinguishing it from siblings like get_draft (single) or list_bookmarks (bookmarks).

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

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

The description mentions the optional status filter and the requirement of a paid Creator/Lifetime plan. While it doesn't explicitly state when not to use it (e.g., for a single post use get_draft), the context of siblings makes it clear. However, more explicit guidelines would improve the 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?

No annotations are provided, and the description only states the action without disclosing behavioral traits such as idempotency, rate limits, or whether it's a safe read-only operation. The agent has minimal insight beyond the surface.

Agents need to know what a tool does to the 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, clear sentence with no wasted words. It is front-loaded and efficient, though slightly more detail could be beneficial.

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

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

For a simple list tool with no parameters and no output schema, the description is adequate but not rich. It does not specify the output format or whether pagination applies, leaving some ambiguity for complex use cases.

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

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

With no parameters and 100% schema coverage, the description adds no additional meaning to parameters. The baseline score of 3 is appropriate as the schema already handles 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?

Description uses a specific verb 'List' and resource 'labels/tags', clearly indicating the action and what is being listed. It distinguishes itself from sibling tools like add_labels and remove_labels by focusing on retrieval.

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

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

No guidance on when to use this tool versus alternatives like add_labels or remove_labels. The description lacks context on prerequisites or typical use cases, leaving the agent to infer.

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

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

With no annotations, the description carries full burden. It states the return structure (slug, name, description, filter query, tabs) and that it's scoped to the user. Missing details like pagination, sorting, or authentication requirements, which are common for such lists. Adequate but not comprehensive.

Agents need to know what a tool does to the 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 efficiently state purpose, alias, definition, and return fields without waste. Front-loaded with primary action.

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

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

Given zero parameters and no output schema, the description covers the essential semantics: what a smart folder is, what the tool returns, and how the slug is used. Sufficient for agent 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?

No parameters exist, and schema coverage is 100% trivial. Baseline is 4 per guidelines; description is not required to add parameter info. No issues.

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

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

Description clearly identifies the action ('List') and resource ('user's smart folders'), provides synonyms ('filtered views / triage views'), and distinguishes from siblings by mentioning the return fields (slug, name, etc.), implying it's the bulk listing tool while get_smart_folder handles single items.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 when you need an overview of all smart folders, but does not explicitly state when to use alternatives (e.g., get_smart_folder for a single folder) or any exclusions. Minimal but adequate.

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

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

No annotations provided, so description carries full burden. It mentions read-only behavior implicitly (retrieve memory) and optional query, but doesn't explicitly state it's non-destructive or side-effect-free.

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

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

Two sentences, front-loaded with purpose, no wasted words. Every sentence adds value.

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

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

Given no output schema, the description adequately explains return value (memories). Simple tool, fully described for its complexity.

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

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

Schema covers the single parameter 100%, and description adds useful context: 'free-text filter', 'omit to get full digest', which adds value beyond schema.

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

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

Clearly states it retrieves durable memories (preferences, voice, facts, instructions) about the user, distinguishing it from sibling tools like 'remember' and 'forget'.

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

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

Explicitly says 'Use this when you need to recall the user's preferences or voice before answering or drafting.' No explicit when-not-to-use, but context is clear.

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

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

With no annotations, the description carries full burden. It discloses overwrite behavior by default, the 'append' mode, and the possibility of refusal when user-set values take precedence. It also gives error-handling guidance. No contradictions are present.

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

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

The description is a single paragraph of 7 sentences. It starts with the core purpose and then details parameters and constraints. While not overly long, it could be improved with bullet points or clearer separation of parameter details. It is concise but slightly dense.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 4 parameters, no output schema, and no annotations, the description covers all essential behavioral aspects: what the tool does, parameter semantics, error/refusal handling, and security warnings. An agent can safely invoke this tool based solely on the description.

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

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

Although the input schema provides 100% coverage, the description adds significant value: it explains the meaning of each 'kind' in natural language, describes 'key' as a 'short stable slug', clarifies the 'mode' parameter's defaults and usage, and suggests a character limit. This goes well beyond the schema.

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

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

The description uses the strong verb 'Persist' and clearly identifies the resource as 'durable facts, preferences, writing-style traits, or standing instructions' for future conversations. It distinguishes itself from siblings like 'recall' and 'forget' by specifying the write operation.

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

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

The description provides explicit when-to-use scenarios with concrete examples (e.g., 'always keep replies short'). It also states what not to store (secrets, passwords). However, it does not directly compare itself to sibling tools like 'recall' or 'forget', though the context of writing vs. reading/deleting 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?

No annotations are provided, so the description must cover behavioral traits. It states the tool removes labels, which implies a destructive mutation, but does not discuss side effects (e.g., what happens if the label doesn't exist, or if some post_ids are invalid), leaving critical behavior undisclosed.

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

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

The description is extremely concise, with two front-loaded sentences that deliver the core action and a key constraint without any fluff.

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

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

For a mutation tool with 3 parameters, no output schema, and no annotations, the description omits important context such as return values, error handling, or behavior when label doesn't exist, making it only minimally complete.

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

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

Schema description coverage is 100%, and the description merely repeats the mutual exclusivity of label_id/label_name already noted in the schema. It adds no new semantic meaning beyond the schema's own comments.

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

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

The description clearly states the action ('Remove labels from bookmarked posts') and the required parameter constraint, distinguishing it from sibling tools like 'add_labels' and 'remove_labels_by_filter'.

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

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

The description provides guidance that either label_id or label_name must be provided, but does not explicitly distinguish when to use this tool over 'remove_labels_by_filter' or other siblings, leaving selection ambiguous.

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

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

Without annotations, the description details key behaviors: it's a single server-side call, returns matched/removed/failed counts, and includes truncation handling. However, it does not explicitly state that it's destructive or mention any prerequisites, which would have earned a 5.

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

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

The description is compact with two dense sentences. The first sentence states the core purpose and distinguishes from a sibling. The second covers usage guidelines and return value interpretation. No wasted words.

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

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

Given the complexity (13 parameters, no output schema), the description covers the return format, truncation flag, and the automatic scoping to posts carrying the label. It does not explain handling of multiple labels or error cases, but the main data flow is well conveyed.

Complex tools with many parameters or behaviors need more documentation. 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%, providing descriptions for all 13 parameters. The description adds some context about the overall parameter usage (e.g., 'Provide label_name or label_id' and scoping), but does not significantly expand beyond what the schema already captures. Baseline 3 is appropriate.

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

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

The description clearly states the action ('REMOVE a label from ALL bookmarks matching a filter') and explicitly distinguishes it from siblings like 'tag_bookmarks_by_filter' and the alternative of chaining list/search with remove_labels. The verb+resource combination is specific and unambiguous.

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

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

The description provides explicit when-to-use guidance ('Use this — NOT list/search + remove_labels on page ids — whenever the user asks to remove/clear a label from many posts') and mentions alternatives, making it easy for an agent to select this tool 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?

With no annotations provided, the description carries the full burden. It discloses the action (publish/schedule), the publish_at semantics, and a prerequisite (paid plan). However, it does not mention what happens to the draft after scheduling (e.g., state change), potential failure modes, or any side effects like overwriting existing schedules.

Agents need to know what a tool does to the 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: the first states purpose, the second explains the key parameter (publish_at), and the third covers requirements. No superfluous information, front-loaded with the most critical details. Every sentence serves a purpose.

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

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

Given the tool has 6 parameters (2 required) and no output schema or annotations, the description covers the most critical aspects: what the tool does, how to specify timing, and prerequisites. It lacks details on the outcome (e.g., confirmation, scheduled time) but is otherwise complete for invoking the tool correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining 'next-slot' as 'the next free slot in the user's posting schedule', and clarifies the timezone requirement conditionally. While most parameter meaning can be inferred from the schema, these additions improve usability.

Input schemas describe structure but not intent. Descriptions should explain 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 schedules or publishes a draft to LinkedIn ('Schedule a Content Studio draft to publish to LinkedIn, or publish it immediately'). This specific verb+resource combination distinguishes it from sibling tools like create_draft, cancel_scheduled_post, or update_draft.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 about when to use (e.g., scheduling vs immediate publish) and requirements (timezone for scheduling, paid plan). However, it does not explicitly instruct the agent when not to use this tool or suggest alternatives (e.g., use create_draft first). The guidance is present but not comprehensive.

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

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

No annotations provided, but the description discloses key behaviors: two search methods, pagination, default sort, filter specificities (hide_archived defaults true, is_unread_only omit unless asked). Does not mention output shape or performance, but is highly transparent for a search tool.

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

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

The description is well-structured with front-loaded main purpose and bullet-like points. It is slightly lengthy but every sentence adds value; could be tightened by removing redundancy in parameter descriptions that are repeated in schema.

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

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

Given 15 parameters and no output schema, the description covers usage patterns, defaults, and edge cases thoroughly. It lacks explicit description of the return format, but the context of a search tool makes the output somewhat predictable.

Complex tools with many parameters or behaviors need more documentation. 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 description adds rich semantic meaning: warnings against using q for author names, clarification of vector_search_term for natural language, fuzzy matching for author, and explicit handling of comment and media_type filters. Each parameter has actionable guidance 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 searches LinkedIn bookmarks via keyword or semantic search, distinguishes from siblings like list_bookmarks and search_docs by detailing two search modes and supported filters.

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

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

Provides explicit when-to-use guidance: requires at least one of q, vector_search_term, or author; explains when to use author instead of q; offers parameter-specific advice for media_type, hide_archived, is_unread_only, and comment.

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

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

No annotations provided. Description implies the tool is read-only (returns help sections), but does not explicitly state behavioral traits like non-destructive nature, rate limits, or authentication needs. With no annotations, the description could do more.

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

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

Concise, front-loaded with purpose, followed by examples and limitations. Every sentence adds value, no wasted words.

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

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

Despite no output schema, description adequately explains what the tool returns (sections of help guide) and how to use the results (answer in own words, point to page). Could mention any limits on result count, but overall 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?

Single parameter 'query' has full schema coverage. Description adds value by clarifying what the query should contain, providing examples, and noting the default behavior when query is omitted. This goes beyond the schema alone.

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

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

The description clearly states it answers questions about Linkedmash's features, settings, and pricing. It explicitly differentiates from siblings by stating it reads product documentation only, not user's saved posts or account data, distinguishing it from tools like search_bookmarks.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 use cases and example queries. Implicitly limits to product documentation, but does not explicitly state when not to use or list alternative tools for other queries.

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

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

No annotations provided, but the description discloses that it 'replaces' the existing schedule (destructive) and requires a paid plan. It also explains how slots drive 'next-slot' scheduling, adding behavioral context beyond the schema.

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

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

Two short sentences that convey essential information without fluff. Each sentence adds unique value: the first defines the action and parameters, the second provides an example and a constraint.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 and only two parameters, the description covers the core behavior and requirements. It lacks explicit mention of the return value or side effects like replacing existing schedule, but the 'Replace' verb implies that.

Complex tools with many parameters or behaviors need more documentation. 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 descriptions. The description adds an example structure for the 'grid' parameter but does not significantly enhance understanding beyond what the schema already provides. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool replaces the user's recurring posting schedule with a weekly time-slot grid and timezone. It distinguishes itself from sibling tools like get_posting_schedule (read-only) and schedule_post (single post) by specifying it sets a recurring schedule.

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

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

The description implies usage for setting recurring schedules but does not explicitly state when to use this tool vs alternatives like schedule_post for one-off posts. Lacks '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?

No annotations, so description carries full burden. Discloses async nature and time requirement. Lacks details on idempotency or side effects if already set up, but sufficient for safe operation.

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

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

Purpose is front-loaded. Instructions are detailed and repetitive ('CRITICAL', 'ALWAYS'), but necessary for correct invocation. Could be tighter but still effective.

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

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

Covers preconditions (error condition, user confirmation), action steps (do not re-run search, call this), and post-action (inform user of async delay). Complete for a setup tool with no parameters.

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

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

No parameters; schema coverage is 100%. Description adds no param info, but that's acceptable as there are none. Baseline for 0 params 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?

Clearly states 'Initialize the vector store for semantic search.' Distinct from sibling tools which focus on bookmarks, drafts, labels, etc. No ambiguity.

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

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

Provides explicit conditions for invocation: when vector search fails with specific error and user confirms with listed phrases. Warns not to re-run search and instructs to inform user about async operation.

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

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

No annotations provided, so the description carries full burden. It discloses that it's a single server-side call, returns matched/tagged/failed counts and a truncated flag, and instructs the agent on how to communicate results to the user. Does not cover permission requirements or potential side effects beyond labeling, but otherwise thorough.

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

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

The description is front-loaded with the core purpose and usage guidance. While lengthy, every sentence adds practical value. A slight redundancy in listing filter criteria could be trimmed, but overall efficiently packed with necessary information.

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

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

Given 13 parameters, no output schema, and no annotations, the description is remarkably complete. It covers response handling (counts, truncated, failed), parameter usage with real user examples, and distinguishes from sibling tools. Addresses almost every scenario an agent might encounter.

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

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

Despite 100% schema coverage, the description adds significant meaning: explains date parameter semantics (posted_* vs bookmarked_*), clarifies that label_name creates if missing, provides default behaviors for hide_archived and is_unread_only, and explains comment filter options. Goes well beyond the schema descriptions.

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

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

The description clearly states the tool adds a label to ALL bookmarks matching a filter in one server-side call. It uses specific verbs and resources (e.g., "tag/label many posts") and distinguishes itself from sibling tools like add_labels and search_bookmarks.

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

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

Explicitly tells when to use this tool (bulk tagging by date range, author, tag, media type, unread status) and when not to ("Never paginate or loop add_labels"). Provides detailed date targeting instructions and clarifies when to use posted_* vs bookmarked_* parameters.

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

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

No annotations provided, so description carries burden. Clearly states it records export and doesn't return file, and directs user to Export Center. Could add more about response format or error scenarios.

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

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

Efficient sentences with no fluff. Front-loaded with purpose and usage, followed by scoping and post-call instructions.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 6 parameters and no output schema, description covers input semantics and return behavior (message with Export Center link). Could mention error handling or rate limits, but sufficient for typical use.

Complex tools with many parameters or behaviors need more documentation. 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%, but description goes beyond by explaining defaults, scoping options, and critical warnings (e.g. unasked filter exports wrong subset). Adds real 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?

Clear verb+resource (export saved posts to CSV). Distinguishes from siblings by specifying CSV/spreadsheet format, but doesn't explicitly contrast with JSON or PDF export triggers.

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

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

Explicitly states when to use (user asks for CSV/spreadsheet export), describes default whole library behavior and how to scope with post_ids or filter, and instructs to tell user about Export Center.

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

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

No annotations exist, so the description fully handles transparency. It discloses that the tool 'records the export — it does NOT return the file' and instructs the agent to inform the user about the Export Center link. This clearly sets expectations about async behavior and required follow-up.

Agents need to know what a tool does to the 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 paragraph that front-loads the purpose and uses every sentence to add value. It could be improved with bullet points or clearer separation of sections, but it remains concise and well-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?

Given 6 parameters, no output schema, and no annotations, the description covers all necessary behavioral aspects: default behavior, filtering scopes, async recording, and user instruction. It is complete for the tool's complexity.

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

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

With 100% schema coverage, the description adds significant value beyond the schema. It explains filter and value pairing, warns against unasked filters exporting wrong subsets, and clarifies shorthand parameters like author and 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 clearly states the tool's function: 'Start exporting the user's saved LinkedIn posts to a JSON file'. It uses a specific verb and resource, distinguishing it from siblings like trigger_csv_export and trigger_pdf_export by mentioning JSON format.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 instructs when to use: 'when the user asks to export/download/back up their saved posts as JSON'. It provides defaults and scoping options, but does not explicitly exclude cases (e.g., CSV/PDF requests) or contrast with 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?

With no annotations provided, the description fully carries the burden of behavioral disclosure. It explicitly states the tool is async ('kicks off an async job — it does NOT return the file'), warns about export duration (up to a minute), and instructs the agent to direct the user to the Export Center.

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

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

The description is four well-structured sentences. Each sentence serves a distinct purpose: purpose, use cases, scoping options, and async/notification behavior. No filler or redundancy.

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

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

Given there is no output schema and six parameters, the description covers all necessary context: async nature, user notification steps, parameter scoping guidance, and the default behavior. It is complete for an AI agent to select and invoke correctly.

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

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

The schema covers 100% of parameters, so baseline is 3. The description adds value by explaining the filter/value pairing, warning about silent wrong subsets, and clarifying default behavior when parameters are omitted. However, it does not detail every parameter 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 starts with a clear action verb and resource: 'Start exporting the user's saved LinkedIn posts to PDF.' It also distinguishes from sibling tools like trigger_csv_export and trigger_json_export by naming the target format.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 specifies when to use the tool (when user asks to export/download/back up saved posts as PDF) and provides example queries. It also explains the default behavior (whole library) and how to scope, though it does not explicitly mention when to avoid this tool in favor of 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?

With no annotations provided, the description carries the burden. It discloses partial update behavior (only provided fields change) and a key constraint: 'content' is required for non-trash updates. It also states the plan requirement. However, it does not discuss error handling, return format, or idempotency.

Agents need to know what a tool does to the 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, efficient sentence that front-loads the action and resource. Every phrase earns its place: action, resource, partial update, content requirement, plan requirement. No wasted words.

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

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

For a simple update tool with 6 parameters and no output schema, the description covers purpose, partial nature, content requirement, and plan requirement. It lacks details on return values (e.g., whether the updated draft is returned) and omits error conditions, but overall it is sufficiently complete for an agent to use correctly.

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

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

The schema description coverage is 100%, baseline 3. The description adds value by clarifying partial update (only provide fields to change) and specifying that content is required for non-trash updates, which modifies the schema's optionality in a specific context.

Input schemas describe structure but not intent. Descriptions should explain 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 updates a Content Studio draft by ID and specifies it is a partial update (only fields to change). This effectively distinguishes it from sibling tools like create_draft, delete_draft, and list_drafts.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives. While it hints at non-trash updates requiring content, it does not mention delete_draft for trashing or create_draft for creation. The plan requirement is a prerequisite, not usage comparison.

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

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

No annotations; description implies partial update ('Provide only the fields to change') but lacks explicit behavior on side effects, permissions, or error states.

Agents need to know what a tool does to the 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 well-structured sentences, front-loaded with action, no wasted words.

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

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

Covers input fields and prerequisite; misses explanation of output/return value and whether it's a partial update, but generally 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 100%; description adds minor clarification (e.g., 'triage_buckets (the tabs/stages)') but mostly restates schema.

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

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

Clearly states 'Update a smart folder (filtered view) by its slug.' Differentiates from create and delete siblings.

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

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

Explicitly lists fields to change and directs to list_smart_folders for slug lookup, but doesn't mention when not to use.

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

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

With no annotations, the description discloses key behaviors: hosting and returning a public URL, the advantage of remote URLs persisting until publish, and the paid plan requirement. It does not detail error handling or size limits but gives sufficient 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?

The description is three sentences, front-loaded with purpose, and each sentence adds necessary information without redundancy. It is efficient and well-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?

The description explains how to use the returned URL (as media_url with matching post_type) and the prerequisites. It covers both input methods and their tradeoffs, though it lacks details on response format or error cases. Given the tool's moderate complexity and no output schema, it is fairly complete.

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

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

Schema coverage is 100%, providing a baseline of 3. The description adds value by explaining usage context: remote URLs are recommended for reliability, file_base64 is better for small files, and file_name is required with base64. This goes beyond the schema's descriptions.

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

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

The description clearly states the tool hosts images, videos, or PDFs and returns a public URL for post attachment. It specifically mentions the verb 'Host' and the resource, distinguishing from sibling tools focused on bookmarks and drafts.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 remote URLs (recommended for availability until publish) vs. file_base64 (best for smaller files) and notes the paid plan requirement. However, it does not explicitly contrast with alternative tools or state when not to use this tool.

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