linkedmash

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

No annotations provided, so the description carries full burden. It only repeats the schema info about creating labels when label_name is provided. Lacks disclosure of authorization needs, idempotency, or effects on existing labels.

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?

Very short (two sentences), but contains an inaccuracy: schema only requires post_ids, while description claims label_id or label_name must be provided. This reduces reliability despite conciseness.

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 3 parameters, no output schema, and no annotations, the description is too minimal. It does not explain return values, error handling, or batch behavior, leaving the agent underinformed.

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%, baseline 3. The description adds the mutual exclusivity constraint between label_id and label_name, which is not enforced by the schema, providing valuable semantic clarity.

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 labels to bookmarked posts, with specific verb and resource. It distinguishes from sibling 'remove_labels' by the action.

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

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

The description imposes a parameter constraint (either label_id or label_name must be provided), but does not explain when to use this tool vs alternatives like 'remove_labels' or when to choose label_id over label_name.

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

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

No annotations provided; description mentions action and requirement but does not disclose side effects, reversibility, or confirmation of cancellation. Adequate but minimal.

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

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

Single sentence with all essential information, 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?

Simple tool with one parameter; description covers key aspects (action, source, requirement). No output schema needed, but could mention outcome briefly.

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 parameter with description; description adds context that ID comes from get_queue entries, enhancing understanding 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?

Description clearly states 'Cancel a scheduled post' with specific source of schedule id and required plan, distinguishing it from sibling tools like schedule_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?

Explicitly mentions prerequisite (paid Creator/Lifetime plan) and hints at usage context (from get_queue entry), though lacks explicit 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?

Despite no annotations, the description discloses key behaviors: it creates a draft, returns the draft with its ID, and requires a paid plan. It implies a write operation but lacks details on idempotency, error handling, or rate limits. Still, it adequately informs the agent about the tool's core behavior.

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

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

The description is concise, with three short sentences and a final note. Every sentence adds value: what it does, how to use a key parameter, what is returned, and a prerequisite. No filler or redundancy.

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

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

For a tool with 7 parameters and no output schema, the description covers the main action and return value but does not address other parameters like 'media_url' or 'post_type'. It leaves the agent to infer media handling from the schema alone, which is a gap for a creation tool.

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

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

Schema description coverage is 100%, so the schema already explains all parameters. The description repeats the 'content' parameter usage but adds no additional semantics or constraints 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 action ('Create'), the resource ('a new LinkedIn post draft'), and the location ('in the user's Content Studio'). It also specifies the return value and a prerequisite, making the purpose unmistakable even among sibling tools like 'update_draft' or 'delete_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 a usage hint ('Put the post body text in 'content'') and a prerequisite ('Requires a paid Creator/Lifetime plan'), but does not explicitly contrast with alternatives or specify when not to use this tool instead of related ones like 'schedule_post'.

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

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

No annotations are provided, so the description must carry the burden. It explains that the tool creates a folder and returns the created object with its slug. However, it does not discuss side effects, prerequisites (e.g., user having saved posts), or error cases. The behavior is adequately described for a creation 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 concise and front-loaded: first sentence defines the tool, second covers key parameters, third states the return value. Every sentence earns its place without 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 relative simplicity and the absence of an output schema, the description covers the essential aspects: what it creates, required and optional parameters, and the return value. It could mention the scope (user's posts) or that the folder starts empty, but it is largely complete for an agent to use effectively.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal value beyond the schema, noting that 'name' is required and 'triage_buckets' are optional, but these are already implied in the schema structure. No significant additional meaning is provided.

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 creates a smart folder (a filtered view), using the specific verb 'Create' and identifying the resource as 'smart folder'. It explains what a smart folder is, setting it apart from sibling tools like update_smart_folder or 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 when to use the tool (to create a new smart folder) but does not explicitly state when not to use it or provide alternatives like update_smart_folder. The name and purpose are clear, but lacking explicit guidance on 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 adds 'move to trash' indicating a reversible action and notes plan requirements. However, it does not disclose side effects, reversibility duration, or required permissions beyond plan.

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

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

The description is two sentences, front-loaded with the action and resource, and contains no fluff. Every word is necessary.

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

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

For a simple delete tool with one parameter, the description covers the action and a prerequisite. However, it lacks details on return value, error conditions, or id format, which would be useful for a complete 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% and the parameter's schema description already covers its purpose. The description adds 'by its id' which mirrors the schema. No additional semantic value beyond what is in the schema.

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

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

The description clearly states the action 'delete' with the nuance 'move to trash' and specifies the resource as 'a Content Studio draft by its id'. It differentiates from siblings like cancel_scheduled_post and get_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 mentions a prerequisite (paid plan) but does not explicitly guide when to use this tool versus alternatives like cancel_scheduled_post or update_draft. Usage is implied but not explicitly contrasted.

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 must cover behavior. It states that only the folder is deleted, not posts. Though does not mention irreversibility or permissions, it is sufficient for a straightforward delete operation. Minor gap in not stating if action is destructive.

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

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

Two sentences with no redundancy. The first sentence gives the core purpose, the second clarifies scope and provides a helpful cross-reference. Perfectly front-loaded.

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

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

Given the tool's simplicity (one parameter, no output schema), the description covers everything needed: what it does, what it doesn't do, and how to find the required slug. No gaps for practical use by an AI agent.

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

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

The only parameter 'slug' is already described in the schema; the description adds context by explaining 'by its slug' and instructs to use list_smart_folders to find it, which adds value beyond the schema.

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

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

The description clearly states the action ('delete') and the resource ('smart folder'), and specifies the method ('by slug'). It distinguishes itself from create_smart_folder and list_smart_folders by mentioning slug lookup.

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: to remove the saved filter/workflow, and importantly what it does NOT delete (saved posts). Provides a direct cross-reference to list_smart_folders for finding the slug.

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

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

With no annotations provided, the description carries full burden. It states that memories are 'removed' but does not disclose permanence, reversibility, idempotency, or effects on related data. For a deletion tool, this lacks crucial behavioral details.

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 fluff. The first sentence states the action and parameters; the second provides usage context. Every word earns its place, and the 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 simple two-parameter deletion tool with no output schema, the description fully covers purpose, usage scenarios, and parameter effects. No additional information is needed to invoke it correctly.

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

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

Although schema coverage is 100%, the description adds significant meaning beyond the schema. It explains that 'key' removes all memories with that key, and clarifies that omitting 'kind' deletes across all kinds. This directly helps the agent understand scoping and behavior.

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

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

The description clearly states the action ('Delete') and the resource ('a durable user memory') with specific constraints ('by its key', 'optionally scoped to a kind'). It distinguishes from sibling tools like 'remember' and 'recall' by naming the forget scenario.

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 specifies when to use: 'when the user asks you to forget something...or to correct an outdated preference/fact before re-adding it with remember.' It provides context for both direct user requests and maintenance scenarios, though it does not explicitly list 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?

No annotations provided, so description must carry the burden. It discloses that a paid plan is required and lists the data returned. However, it does not mention rate limits, caching, or historical data depth. Transparent enough for a read tool but lacks some behavioral detail.

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 and metrics, then time window and requirement. No superfluous 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?

For a simple tool with one optional parameter and no output schema, the description is nearly complete. It explains what the tool returns and the prerequisite. Could mention that analytics are for the authenticated user's account, but that's implied.

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 one parameter described. The description adds valuable examples ('7d', '30d', '90d') and defaults, clarifying usage beyond the schema's generic 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?

Clearly identifies the action ('Get'), the resource ('account-level LinkedIn analytics'), and lists specific metrics (impressions, reactions, etc.). Distinguishes from sibling 'get_post_analytics' which is for individual 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?

Specifies prerequisites (paid Creator/Lifetime plan) and gives examples of valid date_range values. Does not explicitly contrast with alternatives, but the sibling list implies that for post-specific analytics another tool exists.

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?

Since no annotations are provided, the description carries full burden. It discloses that the tool returns 'full content, author, media and tags', which conveys read-only behavior. It does not explicitly state 'no side effects', but the 'get' verb implies it clearly.

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

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

The description is two sentences, front-loaded with the core purpose, and contains no unnecessary words. Every sentence provides value.

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

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

For a simple tool with one parameter and no output schema, the description is complete: it explains what the tool does, what data it returns, and a typical use case. Nothing essential is missing.

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

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

The schema description coverage is 100% (the 'id' parameter is described in the schema). The tool description reiterates the parameter ('by its post_id') but adds no new semantic information 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's function: 'Get a single saved LinkedIn post (bookmark) by its post_id — full content, author, media and tags.' It uses a specific verb and resource, and distinguishes from siblings like list_bookmarks (which lists all bookmarks) and search_bookmarks (which searches).

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

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

The description explicitly states when to use the tool: 'Use this to read one specific saved post' and gives a concrete example ('e.g. before creating content based on it'). It does not mention when not to use it or direct alternatives, but the use case is clear enough.

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

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

No annotations provided; description only states 'get the total count'. Lacks disclosure of performance characteristics, default filters (e.g., whether archived are counted), or any limitations.

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

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

Single sentence with no wasted words. Front-loaded with verb and resource. 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?

Output schema is absent, but description doesn't clarify return format (e.g., integer or object). With 10 parameters, no guidance on parameter interaction. Adequate for a simple count but could be more helpful.

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. Description adds no additional parameter context beyond schema; it just mentions 'optional filtering' generically.

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 a count of bookmarks with optional filtering. Distinguishes from siblings like list_bookmarks (returns items) and get_bookmark (single item) by focusing on count.

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?

Implied usage for counting filtered bookmarks, but no explicit when-to-use or when-not-to-use. Does not mention alternatives like list_bookmarks or search_bookmarks.

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 must disclose behavioral traits. It only states the plan requirement, but omits details like error handling for missing IDs, return format, or rate limits.

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

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

Two concise sentences front-load the action and include a plan requirement without 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 low complexity (1 param, no output schema), the description is adequate but could benefit from specifying what is returned or error behavior.

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

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

Schema coverage is 100% for the single parameter, and the description does not add extra meaning beyond what the schema already provides. Baseline of 3 is appropriate.

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

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

The description clearly states the action 'Get' and the resource 'a single Content Studio post/draft by its id', distinguishing it from list_drafts and other get_* tools.

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

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

The description mentions a prerequisite ('requires a paid plan') but does not explicitly state when to use this tool vs alternatives or provide exclusions. Usage is implied by the context of retrieving a single 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?

No annotations provided, so description carries full burden. Discloses the paid plan requirement but does not specify whether the tool is read-only, side effects, or authorization needs. Adequate but not rich 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?

Two sentences: first describes contents, second gives usage guidance and requirement. Efficient and front-loaded, though first sentence is dense. 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 no input parameters or output schema, the description explains the digest's components well. Lacks details on output format or interpretation, but sufficient for a read-only tool with no inputs.

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

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

Input schema has no properties, so no parameters to document. Schema description coverage is 100% (vacuous). Baseline of 4 applies as description need not add param info.

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 the user's growth digest, listing specific components (positioning, content pillars, authority gaps, next steps, weekly numbers). It uses the verb 'Get' and resource 'GROWTH DIGEST', and distinguishes from siblings like 'get_analytics' by focusing on strategic growth advice.

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 specifies when to use: 'whenever the user asks what they should post/do next, wants a growth plan or weekly review, or asks how to build authority'. Also mentions the plan requirement. Lacks explicit when-not or alternatives, but guidance 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 the burden. It implies a read-only operation ('Get') and discloses a subscription requirement, but does not explicitly state safe behavior, rate limits, or side effects. For a simple read tool, this is marginally adequate.

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

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

The description is two sentences with no extraneous information, front-loading the core purpose. It is efficient and readable, though the requirement sentence could be integrated more smoothly.

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 exists, but the description lists example return fields (impressions, engagements) which helps. However, it lacks details on response structure, pagination, or error conditions. For a tool with 2 parameters and no nested objects, this is adequate but not thorough.

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 minimal context ('time window' for date_range, 'recently published' for limit) but does not provide additional meaning 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 retrieves per-post LinkedIn analytics for recently published posts, specifying metrics like impressions and engagements. However, it does not explicitly distinguish itself from the sibling tool 'get_analytics', which is likely broader, leaving some ambiguity.

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

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

The description mentions a requirement (paid plan) but provides no guidance on when to use this tool versus alternatives like 'get_analytics'. No when-not-to-use context or alternative suggestions are given.

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

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

With no annotations, the description carries full burden but only states it gets the schedule and requires a paid plan. It does not disclose behavioral traits like side effects, data freshness, or rate limits, which are minimal but could be clearer for a read 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?

Two concise sentences without any fluff. The first sentence clearly defines purpose and output, the second adds a requirement. 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 no output schema and simple tool, the description provides adequate context: what is returned and a prerequisite. It could be slightly more complete with a hint that it reflects the user's saved schedule, but it is largely 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?

There are no parameters (schema is empty), so the baseline is 4. The description adds meaning by explaining that the tool returns a weekly time-slot grid and timezone, which compensates for the lack of 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?

The description clearly states the verb 'Get' and the resource 'recurring posting schedule', specifying it returns the weekly time-slot grid and timezone, which differentiates it from siblings like 'get_posting_slots' and '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 includes a prerequisite (paid plan) but provides no guidance on when to use this tool versus alternatives like 'set_posting_schedule' or 'get_posting_slots'. Implicitly it's for viewing, but no explicit usage context.

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

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

With no annotations provided, the description carries full burden. It discloses that the tool returns slots from the user's recurring schedule and requires a paid plan, but does not explain error cases, behavior if no schedule exists, or whether this is read-only (though 'get' suggests it).

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

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

The description is two concise sentences, front-loaded with the purpose, and includes critical context about 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?

Given no output schema, the description could better describe the return format. It mentions timestamps but doesn't specify the full response structure or edge cases. Still adequate for a simple tool with few parameters.

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

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

Schema coverage is 100% with descriptions for both count and timezone. The description adds usage context for returned values but does not enhance parameter meanings 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 retrieves the next free posting slots from the user's recurring schedule in their timezone, differentiating it from siblings like schedule_post and get_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 provides specific guidance on using returned slot timestamps as publish_at when scheduling, and mentions the requirement of a paid plan. However, it does not explicitly state when not to use this tool or list 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 status filter, schedule id for actions, and plan requirement. Lacks pagination info but is sufficient for a read 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?

Two sentences, front-loaded with main purpose, 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 main function, grouping, filter, schedule id usage, and plan requirement. Could mention return format but is adequate for a simple list tool with no output schema.

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

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

Schema coverage is 100% for status parameter. Description confirms optional filtering and adds context, but does not add significant meaning beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool lists the user's posting queue with scheduled and published LinkedIn posts grouped by date, distinguishing it from siblings like 'cancel_scheduled_post' or 'get_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 implies usage by stating it lists the queue and optionally filters by status, but does not provide explicit when-to-use or alternatives compared to siblings like 'get_posting_schedule'.

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 description explains it is a read operation ('Get') and lists what it returns. Could be more explicit about lack of side effects, but sufficient for a simple 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, front-loaded with action, then details, then usage guidance. Every sentence is valuable with no redundancy.

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

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

For a simple tool with one parameter and no output schema or annotations, description covers purpose, usage, returns, and prerequisite. Complete and actionable.

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 slug fully, description adds context that slug comes from list_smart_folders. Adds value beyond schema by explaining source.

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 gets one smart folder by slug, listing specific fields returned (name, description, base_query, tabs). It distinguishes from siblings like list_smart_folders (to find slug) and get_smart_folder_posts (to read posts inside).

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 list_smart_folders first to find the slug' and points to get_smart_folder_posts for reading posts. Provides clear prerequisites and alternative.

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

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

No annotations provided, so description carries full burden. It discloses pagination behavior (numeric offset cursor), filtering via bucket, and source of slug. It implies read-only (list) but does not state explicitly; still adequate.

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

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

Three concise sentences: first states purpose, second gives prerequisite, third explains optional parameters and pagination. No wasted words, front-loaded with key info.

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?

All 4 parameters are covered with clear explanations. Despite no output schema or annotations, the description provides sufficient context for correct invocation. Return format is not described but is typical for list operations.

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% (baseline 3). The description adds value beyond schema by explaining the source of slug, the meaning of bucket (tab/stage/triage bucket), and that cursor is a numeric offset for pagination.

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 saved LinkedIn posts inside a smart folder, specifying the resource (smart folder posts) and action (list with optional filtering by bucket). This distinguishes it from siblings like get_smart_folder (folder metadata) and list_smart_folders.

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

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

The description provides guidance on how to use the tool: get slug from list_smart_folders, optionally filter by bucket, paginate with cursor and limit. It lacks explicit mention of when not to use or alternative tools, but the context is clear.

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

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

No annotations are provided, so the description carries the full burden. It discloses pagination, filtering, sorting, and fuzzy matching for author. However, it does not mention rate limits, data freshness, or that the tool is read-only. Behavior is adequately described 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?

The description is extremely concise: two sentences, zero waste. The first sentence states the core purpose, and the second adds critical usage guidance. Information is front-loaded 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 the tool's complexity (13 parameters, no output schema), the description is reasonably complete. It covers filtering and pagination but does not explain the return format or error handling. However, the schema descriptions are very detailed, compensating for the description's brevity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds significant value beyond the schema by highlighting the author parameter's fuzzy matching and automatic ID resolution. The 'IMPORTANT' note provides real-world usage context that the schema alone does not.

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 bookmarks with filtering and pagination. It also gives explicit usage guidance for the author parameter, setting it apart from generic list tools. However, it does not explicitly differentiate from siblings like search_bookmarks, so a perfect score is not warranted.

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 excellent usage guidance for the author parameter, telling when to use it to find posts by author. However, it lacks broader guidance on when to use this tool versus alternatives like search_bookmarks or get_bookmark. No when-not-to-use advice is given.

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

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

No annotations provided. The description lacks information on pagination, rate limits, read-only nature, or output behavior. It only states the operation and a prerequisite.

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 front-loaded purpose and 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?

The description adequately explains what the tool does and its prerequisite, but omits output structure (no schema) and pagination. Given the simple single-parameter tool, it is 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?

The single parameter 'status' is fully described in the schema with enum and description. The description adds no extra meaning beyond restating the optional filter, so baseline 3 applies.

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

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

The description clearly states the tool lists the user's Content Studio posts (drafts, scheduled, published) and mentions optional status filtering. It distinguishes from siblings like get_draft and create_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 explicit context: listing the user's own posts, optional filter, and paid plan requirement. However, it does not explicitly state when not to use or compare with alternatives like search_bookmarks.

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 disclosure burden. It only states 'list' without indicating whether it's read-only, any side effects, or authentication requirements. Minimal behavioral insight.

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

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

One short sentence with no redundancy. Front-loaded and efficient.

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

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

Lacks output schema and does not describe return format or fields of labels. An agent may not know what the response contains, limiting usability.

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, so schema coverage is 100%. Description adds no extra meaning beyond the schema, but with zero parameters, baseline 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?

Description clearly states action 'list' and resource 'user's labels/tags', distinguishing it from sibling tools like add_labels and remove_labels.

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

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

No explicit guidance on when to use this tool vs alternatives. The description implies it's for retrieving all labels, but lacks context on filtering or alternatives like search tools.

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

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

With no annotations, the description carries full burden. It describes what is returned (slug, name, description, filter query, tabs) but does not mention any side effects, auth requirements, or limitations like pagination. As a list operation, it is likely safe, but not explicitly stated.

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

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

The description is three sentences, front-loaded with the main action, provides necessary background, and specifies the output. Every sentence contributes useful information with 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 tool has no parameters and no output schema, the description adequately explains the return values. However, it omits potential details like ordering, filtering, or limits, which could be relevant for a list operation.

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

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

There are zero parameters, so schema coverage is 100% by default. The description adds value by explaining the meaning of the returned fields (e.g., 'slug (use it with the other smart-folder tools)') beyond the empty schema.

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

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

The description clearly states 'List the user's smart folders' with a specific verb and resource. It explains what smart folders are (filtered views/triage views) and distinguishes from siblings like get_smart_folder or create_smart_folder by mentioning returned fields (slug, name, etc.).

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

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

The description implies when to use this tool (to list all smart folders) but does not explicitly state when not to use it or mention alternatives. Given sibling tools like get_smart_folder, the context is clear, but lacks explicit exclusions.

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

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

Description indicates a read operation ('retrieve') and mentions durable memory, but with no annotations, it falls short of fully describing behavioral traits like side effects, rate limits, or whether the call is safe to repeat. Could be more transparent.

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

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

Two sentences with no wasted words. Purpose and usage are front-loaded. Every sentence earns its place.

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

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

Given the simple structure (1 optional param, no output schema), the description provides sufficient context: what is retrieved, when to use, how to use the parameter. Lacks details on return format, but adequately 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?

The description adds meaning to the single parameter 'query' beyond the schema: explains it is optional and that omitting it returns full digest. Schema coverage is 100%, but the description provides usage 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?

Clearly specifies verb 'retrieve' and resource 'what you durably remember about the user' (preferences, voice, facts). Implicitly distinguishes from siblings like 'remember' and 'forget', but does not explicitly differentiate from all sibling tools.

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

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

Explicitly states when to use: 'when you need to recall the user's preferences or voice before answering or drafting.' Also explains when to omit the query parameter. Lacks explicit when-not-to-use or alternative tool references.

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 write operation, durability across conversations, overwrite vs append behavior, and error conditions. No annotations provided, so description fully carries the transparency burden.

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

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

Description is front-loaded with purpose and well-structured. Could be slightly more concise but 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 purpose, usage, all parameters, and error behavior. No output schema, but description mentions error handling. Lacks detail on success return value, but acceptable for this tool.

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

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

Schema already covers 100% of parameters, but description adds meaningful context: kind categories explained, key as slug, value length limit, mode behavior. Adds significant 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?

Description clearly states the tool persists durable facts/preferences/instructions for future conversations, with specific examples. Distinguishes from siblings 'forget' and 'recall' by implying complementary actions.

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 (user states lasting preference) and provides examples. Includes warnings about sensitive data and error handling. Does not directly contrast with sibling tools 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 the full burden. It only states the action and a parameter constraint, but does not disclose whether the operation is reversible, idempotent, requires special permissions, or any side effects. As a mutation tool, more behavioral context is needed.

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 filler. It is front-loaded and every word earns its place, covering the action, resource, and a key constraint efficiently.

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 removal tool with fully documented parameters and no output schema, the description covers the core action and a crucial parameter rule. However, it could specify that multiple posts can be processed in one call and confirm the scope (one label per call). Still, it is reasonably complete.

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

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

The schema already describes all parameters (100% coverage), but the description adds value by summarizing the mutual exclusivity of label_id and label_name, which the schema hints at but does not enforce explicitly. This helps the agent understand the required combination.

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

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

The description clearly states the verb 'Remove' and the resource 'labels from bookmarked posts', and includes a critical constraint about providing either label_id or label_name. This distinguishes it from its sibling 'add_labels' and other tools.

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

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

The description specifies a key usage condition (must provide label_id or label_name), but does not explain when to use this tool versus alternatives like add_labels or other label-related actions. It lacks explicit when-not-to-use guidance or comparisons to siblings.

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

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

With no annotations provided, the description bears full responsibility for behavioral disclosure. It reveals the publishing destination (LinkedIn), the meaning of each publish_at option, and the timezone requirement. It does not detail error handling or side effects but covers the key behavioral traits for a scheduling 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 extremely concise: three sentences that front-load the primary action and then detail the key parameter semantics and a prerequisite. Every sentence adds necessary information with no redundancy.

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

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

Given the six parameters, no output schema, and no nested objects, the description adequately covers the main use cases and constraints. It could mention the return behavior but is otherwise complete for a tool of this complexity.

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

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

Schema coverage is 100%, so parameters are individually described. The description adds significant value by explaining the semantics of 'publish_at' values ('now', 'next-slot', ISO-8601) and the conditional requirement for 'timezone'. This goes beyond mere parameter names and 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 identifies the tool's action: scheduling a Content Studio draft to publish on LinkedIn, with three distinct scheduling modes (now, next-slot, timestamp). It effectively distinguishes from sibling tools like cancel_scheduled_post and create_draft by specifying the exact operation and resource.

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

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

The description provides clear context on when to use the tool (to schedule or immediately publish a draft) and includes essential preconditions (requires a paid plan, timezone unless 'now'). It does not explicitly exclude usage cases or compare with all siblings, but the guidance is sufficient 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?

With no annotations provided, the description carries the full burden. It discloses the two search modes (keyword and semantic), the required parameter constraint, and parameter-specific rules (e.g., not using 'q' for author). It does not discuss permissions or side effects, but as a search tool, this is acceptable.

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

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

The description is a single paragraph that is relatively concise given the number of parameters and details. It front-loads the most important info (search modes and required parameters). However, it could be slightly more structured with bullet points.

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?

Although the output schema is missing, the description adequately covers the key behaviors and parameter relationships for a search tool. It explains constraints and parameter interactions, but does not describe the return format. Given the complexity (15 parameters), 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%, so baseline is 3. The description adds meaning beyond the schema by clarifying that 'q' is not for author names, 'author' supports fuzzy matching, and 'vector_search_term' is for semantic searches. It also explains the constraint that at least one parameter must be used.

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 through LinkedIn bookmarks using keyword or semantic search. It specifies the verb 'search' and the resource 'bookmarks', and distinguishes from sibling tools like list_bookmarks by mentioning searching vs listing.

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 the 'author' parameter vs 'q' for searching content, and states the requirement that at least one of 'q', 'vector_search_term', or 'author' must be provided. However, it does not explicitly contrast with sibling tools like search_docs for when to use this tool over others.

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 states the tool reads 'product documentation only', returns relevant sections, and instructs to answer in own words and point to exact page. Also covers special case for live prices. No contradictions.

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

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

Description is thorough but slightly lengthy. It front-loads the purpose and uses bullet-style examples. Could be more concise, but every sentence adds useful information.

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

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

For a tool with one parameter and no output schema, the description fully explains what the tool does, what it returns, how to use results, and special cases. It is complete for effective 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?

Schema coverage is 100% with a single parameter 'query' already described. The description adds value by providing example queries and noting that omitting query returns list of help topics, which goes beyond schema basics.

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

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

The description clearly states this tool answers questions about Linkedmash product features, settings, and pricing/billing. It provides numerous specific examples and explicitly differentiates itself from sibling tool search_bookmarks by stating it reads product documentation, not user data.

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

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

Explicitly tells when to use (for product questions) and when not to use (NOT user's saved posts/account data). Includes examples of appropriate queries and a special instruction for live prices.

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

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

The description discloses that the tool replaces (not appends) the schedule and drives 'next-slot' scheduling, which is behavioral. However, with no annotations, it lacks details on reversibility, rate limits, or error conditions. It partially compensates but misses important behavioral traits.

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

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

The description is very concise: two sentences that front-load the purpose and immediately follow with a useful example and prerequisite. No filler or redundant information.

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

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

For a simple setter with two parameters and no output schema, the description covers the core purpose, parameter format, and a key prerequisite. It does not describe return values or error behavior, but these are less critical for a replace operation.

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

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

Schema coverage is 100%, but the description adds an example of the grid structure ({ time: '8:30 am', days: { Mon: true, Wed: true } }), which clarifies the parameter format beyond the schema's brief 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 replaces the user's recurring posting schedule, specifying the resource (posting schedule) and action (replace). It distinguishes from sibling tools like get_posting_schedule (retrieve) and cancel_scheduled_post (cancel single 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 provides clear context for use—setting a recurring schedule—and includes the prerequisite of a paid plan. However, it does not explicitly state when not to use it or mention alternative tools for viewing the schedule.

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, but description discloses the critical async nature ('may take a few minutes'). It does not mention side effects or destructive behavior, but the async info is valuable.

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?

While front-loaded with purpose, the description is verbose with extensive conditional instructions and a list of user response phrases. Could be more concise without losing critical guidance.

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

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

Given zero parameters, no output schema, and no annotations, the description covers the tool's purpose, trigger condition, async behavior, and post-call actions. Missing info about exact effect or reversibility, but adequate for a setup 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?

No parameters exist; schema coverage is 100%. The description adds no param info (unnecessary), and the baseline for zero-param tools is 4.

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

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

The description explicitly states 'Initialize the vector store for semantic search,' which clearly identifies the verb (Initialize) and resource (vector store). It distinguishes this setup tool from sibling search/retrieval 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 explicit when-to-use conditions: only when vector search fails with a specific error and user confirms with listed phrases. Also instructs not to re-run search tool, making the usage context unambiguous.

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

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

Describes return values (matched/tagged/failed/truncated) and agent actions (inform user of counts, mention truncation and failures). Lacks auth or rate limit details, but annotations are absent so description carries full burden. Adequate behavioral disclosure.

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

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

Front-loaded with purpose, then usage guidance, then parameter semantics. Every sentence adds value with no redundancy. Efficiently structured despite length.

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

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

Given 13 parameters, no output schema, and no annotations, the description is remarkably complete. Covers filter types, date mapping, label creation, return handling, and edge cases (truncation, failures). Fully prepares the agent.

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

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

Schema coverage is 100%, but the description adds significant meaning: clarifies date targeting semantics (posted_* vs bookmarked_*, ISO format), explains label_name creation vs label_id, and provides usage examples for q, author, comment, etc.

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

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

The description uses a specific verb+resource: 'Add a label to ALL bookmarks matching a filter'. It clearly distinguishes from sibling tools like list_bookmarks/search_bookmarks followed by add_labels, and specifies the scope as all matching bookmarks in one call.

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 this — NOT list_bookmarks/search_bookmarks followed by add_labels' with concrete examples. Also explains when to use date parameters (posted_* vs bookmarked_*) and instructs to never paginate or loop.

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 fully discloses behavior: it records the export but does not return the file, defaults to whole library, scoping options, and notes the response includes a link. This is comprehensive for a non-destructive export trigger.

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 at 5 sentences, front-loading the main action. It could be broken into bullet points for readability, but it is efficient and waste-free.

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 6 params, no output schema, and no annotations, the description covers the behavior, return value (message with link), and scoping options. It lacks error handling details but is complete enough for agent 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%, and the description adds value by explaining shorthand usage (e.g., filter+value pairs) and clarifying that post_ids can be omitted. It enhances understanding 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 the tool exports saved LinkedIn posts to CSV, using a specific verb and resource. It distinguishes from sibling tools like trigger_json_export and trigger_pdf_export by explicitly mentioning CSV/spreadsheet.

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 tells when to use (user asks to export saved posts as CSV/spreadsheet), how to scope (default whole library or with post_ids/filter), and what not to expect (does not return file). It even instructs to inform the user about the Export Center link.

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 that the tool records export and does NOT return the file, and instructs to tell user about Export Center link. Lacks idempotency/rate limits, but overall good 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?

Two well-organized paragraphs. First covers purpose, second covers scoping and behavioral note. The instruction about telling the user is relevant and front-loaded. 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 6 optional parameters and no output schema/annotations, description covers purpose, usage, parameter guidance, and async behavior. Does not detail response format or failure modes, but sufficient for agent to invoke correctly.

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

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

Schema coverage is 100% (baseline 3). Description adds value by explaining default whole-library export and how parameters scope it (post_ids, filter+value, search_query, tags). Gives examples like 'author/label/type'.

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

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

The description clearly states the verb 'start exporting' and specific resource 'saved LinkedIn posts to a JSON file'. It distinguishes from sibling tools like trigger_csv_export and trigger_pdf_export by specifying JSON.

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 when to use: when user asks to export/download/backup saved posts as JSON. Provides scoping options and clarifies async behavior. Does not explicitly exclude alternatives like CSV/PDF export, but context of sibling tools 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?

Discloses async nature, that it does not return the file, and instructs agent on user messaging. No annotations provided, so description fully covers behavior.

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

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

Single paragraph with clear sentences, each adding value. Could be slightly more structured (e.g., bullet points) but concise enough.

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 tool purpose, async behavior, return flow, and parameter usage adequately. Missing only minor details like rate limits.

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 extra context about default behavior (whole library) and how parameters scope exports, going beyond 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?

Description clearly states the verb 'Start exporting' and resource 'user's saved LinkedIn posts to PDF'. Differentiates from sibling tools by specifying PDF 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?

Provides explicit usage context with example queries and explains scoping options. Lacks mention of when NOT to use or explicit alternatives, but sibling tool names imply 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 the full burden. It discloses the partial update nature, conditional requirement for 'content', and plan requirement. However, it does not mention the return value, error behavior, or any side effects, leaving some gaps for an agent.

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

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

The description is a single concise sentence that packs essential information: action, resource, partial nature, field requirement, and plan prerequisite. No extraneous 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 tool with no output schema and no annotations, the description covers input behavior well. It explains partial updates and a key conditional. It lacks return value info, but given the simplicity of an update operation, it is mostly 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 the baseline is 3. The description adds value by clarifying the partial update semantics and the conditional requirement for 'content' (only for non-trash updates), which goes beyond the schema's individual field descriptions.

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

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

The description clearly states the action ('Update'), the resource ('a Content Studio draft'), and the scope ('by id, partial'). It distinguishes from siblings like create_draft or delete_draft by specifying the partial update behavior and the requirement for 'content' for non-trash updates.

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

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

The description explains when to use the tool (for updating drafts, partial updates) and provides a prerequisite ('Requires a paid Creator/Lifetime plan'). It does not explicitly state when not to use it or mention alternatives, but the partial update hint and plan requirement give clear context.

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

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

No annotations provided, so description must disclose behaviors. It states 'Update' implying mutation but does not mention side effects, permissions, idempotency, or consequences of changing base_query. Lacks detail on the partial update behavior.

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

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

Two sentences, no wasted words. Purpose stated first, then usage instructions. 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?

Given the tool has 5 parameters and no output schema, the description covers the essential aspects: what updates are possible, how to get the slug, and partial update. It could mention the return value or error cases, but it is adequate for an agent.

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

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

Schema has 100% parameter descriptions, so baseline is 3. Description adds value by explaining partial update ('Provide only the fields to change') and clarifying 'triage_buckets' as 'tabs/stages'. Directs to list_smart_folders for the slug, which is helpful.

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 'Update a smart folder (filtered view) by its slug.' Verb 'update' and resource 'smart folder' are specific. Distinguishes from sibling tools like create_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?

Explicitly tells the user to provide only fields to change: 'name', 'description', 'base_query', 'triage_buckets'. Also advises to use list_smart_folders to find the slug. No explicit when-not-to-use, but the guidance 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?

In the absence of annotations, the description discloses the paid plan requirement and the persistence behavior for remote URLs, but omits details on size limits, error handling, or whether file_base64 uploads are ephemeral.

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

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

Two sentences, no wasted words. The first sentence captures purpose and output, the second explains parameters and requirement. 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?

Given the moderate complexity and lack of output schema, the description covers key aspects: input methods, output usage, and plan requirement. It could be improved by mentioning size or format limits, but it is largely 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?

With 100% schema description coverage, the schema already documents each parameter. However, the description adds value by explaining the trade-off between 'url' and 'file_base64' and the plan requirement, which goes 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 verb 'Host' and the resource 'image, video, or PDF', and specifies the outcome: a public URL. It also differentiates from sibling tools (which handle drafts, labels, etc.) by focusing on media upload.

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

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

The description explains when to use 'url' versus 'file_base64' parameters and recommends the remote URL for availability until publish. It also mentions the prerequisite paid plan, though it does not explicitly state when not to use the tool.

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