B2B Creators

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

Beyond the annotations (idempotent, non-destructive), the description discloses that the operation moves rather than copies, that the previous team is reported back, and that ambiguous names return candidates instead of guessing. These are valuable behavioral details not covered by annotations.

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

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

Two sentences, no fluff. The core action and key caveats are front-loaded. 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?

Given there is no output schema, the description covers the critical output (previous team reported back) and the ambiguity fallback. It could describe the success response format more fully, but the essentials are present for a two-parameter tool.

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

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

The schema already documents that parameters accept names or ids. The description adds the behavior for ambiguous names (returning candidates), which is not in the schema. This enriches parameter semantics beyond the baseline for 100% coverage.

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

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

The description states a clear action: placing an influencer into a team, and clarifies it is a move rather than a copy because an influencer belongs to one team at a time. This distinguishes it from creation or update operations among siblings.

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

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

The description implies the tool is used to reassign an influencer to a different team. It does not explicitly name alternatives, but the move semantics are clearly stated and it is distinct from create_influencer or create_team. Could be more explicit about when not to use, but the context is sufficient.

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

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

Beyond the annotation flags, the description discloses the app-visible side effect (a team-influencer plan appears on that influencer's content plan page) and instructs the agent to surface the matched identity to catch wrong matches. This adds meaningful behavioral context not present in annotations, though not every failure or side-effect case is covered.

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

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

Two sentences with no filler, front-loaded with the core action and target types. The behavioral note about telling the user which identity was matched is necessary and compact.

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 is adequate for selecting and invoking the tool, but it omits return-value and error behavior. With no output schema, the agent must infer what the tool returns (e.g., a created plan id), which is a noticeable 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?

The input schema already covers 100% of the parameters with descriptions, so the baseline is 3. The description adds operational guidance about matched identity but does not add new per-parameter meaning beyond the schema.

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

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

The description uses a specific verb ('Create') and resource ('content plan (posting calendar)') and enumerates the target identity types: team influencer, connected profile, or company page. This makes the tool's purpose clear and distinguishes it from sibling tools like list_content_plans or share_content_plan.

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

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

It explicitly states the planning context ('Posts are scheduled inside a plan') and the target selection contexts (team influencer, connected profile, company page). It does not name alternative tools or provide explicit when-not-to-use conditions, but the usage context is clear.

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

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

Annotations are bare (all false hints), so the description carries the full burden — and it delivers richly: side effects (record + personal invite link created), deferred LinkedIn authorization, consequences until authorized (absent from list_profiles, cannot publish), and name-based dedup returning the existing record. Nothing contradicts the annotations.

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

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

Four sentences, each earning its place: core action + UI reference, what the tool does NOT do, downstream consequences, and dedup behavior. The verb-resource is front-loaded in sentence one and there is zero filler.

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

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

For a low-complexity tool (3 params, 1 required, no nested objects), the description covers the creation flow, the deferred-auth state, visibility consequences, and dedup thoroughly. The only notable gap: with no output schema present, the description never states what the tool returns (e.g., the created record and invite link).

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 all 3 parameters at 100%, so baseline is 3. The description adds genuinely new semantics for the required name parameter by documenting the dedup rule ('If someone with the same name already exists, the existing record is returned instead of creating a duplicate'), which is not 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?

States a specific verb-resource pair ('Add a person to the workspace as a team influencer') and anchors the exact semantics to the UI '+ tile' on the influencers page. It is easily distinguished from the sibling add_influencer_to_team by clarifying this tool only creates the record and invite link, not a team placement or LinkedIn connection.

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

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

Gives clear context ('exactly as the + tile on the influencers page does') and a strong when-not ('This does NOT connect their LinkedIn' — the person must open the link themselves). It does not explicitly name alternative tools such as add_influencer_to_team, so exclusion routing is implied rather than stated outright.

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

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

The description adds useful behavioral details beyond the annotations: duplicate names return the existing team, and unmatched members are reported back rather than silently skipped. It does not contradict the annotations, though it could mention error handling or side effects on existing teams in more depth.

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

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

The description is compact and front-loaded: the core creation purpose appears first, followed by optional membership behavior, then edge-case handling. Every sentence adds meaningful operational detail without redundancy.

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

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

For a three-parameter tool with no output schema, the description covers the core operation, the optional members behavior, duplicate-name handling, and unmatched-member reporting. It is sufficient to invoke the tool correctly, though it does not describe the exact response format beyond indicating what is returned.

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

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

Schema coverage is 100%, so the schema already documents all three parameters. The description still adds value by clarifying that members are 'existing influencers' moved into the team and that unmatched ones are reported back, which supplements the schema's parameter descriptions without duplicating them.

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

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

The description uses a specific verb and resource: 'Create a team ... on the influencers page and optionally move existing influencers into it.' It clearly distinguishes from sibling create_influencer by describing the team entity and its optional membership move, so an agent understands exactly what this tool is for.

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

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

The description gives clear context: use it to create a team and optionally move influencers in during creation. It also provides an implicit get-or-create guideline by stating that an existing team with the same name is returned instead of duplicated, but it does not explicitly mention alternatives like add_influencer_to_team for later use.

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

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

The annotations only provide false hints (not read-only, not idempotent, not destructive), so the description carries the full burden of explaining behavior. It discloses that the link is one-time, the upload URL is short-lived, the file can be opened or PUT to, there is a permanent public URL, the workflow requires confirming upload completion, and the file must be under 200 MB. It also explains the alternative for tiny files. This is comprehensive 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?

Four sentences with zero waste. The first sentence states the core purpose, the second explains return values, the third adds a crucial timing caveat, and the fourth provides the tool selection rule and size limits. Everything is front-loaded and every sentence earns its place.

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

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

For a 2-parameter tool with no output schema, the description covers everything needed to call it correctly: what it returns, how to use the response, the upload method (open or PUT), the size constraints, and the relationship to the sibling tool. The agent has all necessary context to invoke and handle the result.

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

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

Schema coverage is 100% (both parameters have descriptions), so the baseline is 3. The description adds meaning beyond the schema by clarifying the file lives on the user's machine, listing supported types (image, video, PDF), and setting the 32 KB threshold and 200 MB maximum. These details help an agent select the right tool and understand constraints without opening 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 states a specific verb and resource: 'Get a one-time upload link for a file... so it can be attached to a post.' It also differentiates itself from sibling upload_media by noting it is the default for files over 32 KB. An agent can clearly identify what this tool does and how it differs from related 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 provides when-to-use guidance: 'This is the default route for real photos, videos and carousel PDFs — anything above 32 KB. upload_media is only for tiny files you are already holding.' It also instructs how to use the result: pass the public URL into media_urls on schedule_post or update_post, and only after the user confirms the upload finished. No ambiguity remains about when to choose this tool over upload_media.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=true, so the safety profile is covered. The description adds the 'unpublished post' scope, which is useful, but it does not disclose additional behavior such as permanence or side effects beyond what annotations already imply.

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 concise sentence with no filler. It states the action, the target object, and the relevant constraint ('unpublished') 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 one-parameter deletion tool with annotations covering destructive and idempotent behavior, the description is nearly complete. It clarifies that the target must be unpublished, and the schema provides the source of post_id. It does not discuss edge cases, but none are required for basic correct invocation.

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

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

The input schema has 100% description coverage and states that post_id comes from list_scheduled_posts. The tool description adds no extra parameter meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Remove') and a clear resource ('unpublished post from the calendar'), and the qualifier 'unpublished' distinguishes it from tools like publish_post_now or update_post. Even though the name and title say 'delete', the description adds concrete scope.

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

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

The description clearly implies the tool is for removing scheduled/unpublished posts that are no longer wanted. It does not explicitly name alternatives or say when not to use it, but the context is unambiguous enough for an agent to select it correctly.

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

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

Annotations already convey read-only, idempotent, and open-world behavior, lowering the bar. The description adds useful context by listing return fields, but it does not disclose pagination, ordering, default limit behavior, or whether all campaigns are included when campaign_ids is omitted. No contradiction with annotations.

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

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

Two sentences with no filler. The first sentence front-loads the core action and return fields, and the second adds the actionable pairing suggestion. Every word earns its place.

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

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

For a simple list tool with fully documented parameters and safety annotations, the description covers the main return content and its relationship to the performance sibling. No output schema exists, but the fields listed are sufficient for an agent to know what to expect; pagination/ordering details are minor 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 coverage is 100%, so the schema already documents all four parameters with descriptions. The description mentions campaign and ad account contextually but adds no meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'List the individual ads in a LinkedIn ad account,' and enumerates the returned fields (copy, headline, format, status, campaign, Thought Leadership flag). It also references the sibling get_ad_performance_breakdown, making it easy to distinguish from performance-focused 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 gives clear workflow context by naming get_ad_performance_breakdown as the companion tool to see performance, implying this tool is for the creative-level ad data itself. It does not explicitly list exclusions or when not to use it, but the pairing instruction makes the intended usage clear.

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

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

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, so the safety profile is covered. The description adds useful behavioral context beyond those hints: it ranks by spend, joins ad copy, and flags Thought Leadership ads, which tells the agent what returned data will look like without contradicting the annotations.

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

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

The description is a compact two-sentence definition that front-loads the core metrics and ranking behavior, then adds a clear use case. Every clause earns its place, including the Thought Leadership clarification, which prevents misinterpretation of a specialized flag. There is no filler or redundancy.

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

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

With no output schema, the description compensates by listing the metrics returned corrected, including 'joined with the ad copy' and the Thought Leadership flag behavior. It also clarifies the analytical use case relative to organic reach. It does not specify the sort direction beyond 'rank by spend' or describe response pagination, but most operational details (limits, date defaults) are already encoded in the input schema.

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

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

Schema description coverage is 100%, and the schema already documents all seven parameters and defaults clearly (e.g., 'Defaults to 30', 'YYYY-MM-DD'). The description adds no param-specific guidance or contextual meaning beyond the schema, so the baseline of 3 applies.

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

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

The description uses a specific verb-resource combination and immediately states a precise behavior: 'Rank individual ads by spend' with a detailed list of metrics (impressions, clicks, CTR, CPC, engagement, leads, cost per lead, video views). It also distinguishes this tool from siblings like get_ads_performance by emphasizing 'per-ad' granularity and 'joined with the ad copy', making the tool's unique scope clear.

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

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

The description explicitly says when to use it: 'Use to work out which ads are working' and 'to compare cost per outcome against the organic reach the team's profiles produce for free'. It provides clear application context but does not name alternative tools or state when not to use it, such as when aggregate campaign performance is needed instead of per-ad breakdowns.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered. The description adds the account-level aggregate scope and the metrics returned, but does not describe output structure, pagination, or other runtime behavior beyond that. This is a reasonable value-add, not a rich 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?

Two sentences with no filler. The action and metric list are front-loaded, and the purpose clause earns its place by explaining why this tool exists relative to organic profile performance.

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

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

For a five-parameter read-only tool with no output schema, the description lists the expected returned metrics and names the relevant sibling alternative. It does not mention date-range defaults or campaign scoping, but those are fully covered in the schema, so nothing critical is missing.

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

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

Schema description coverage is 100%, so the schema fully documents all five parameters, including defaults and the optional ad_account_id behavior. The description does not add parameter-specific meaning beyond the schema, which matches the baseline for high coverage.

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

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

The description names a specific action, resource, and scope: "Fetch account-level LinkedIn Ads performance" and lists concrete metrics. It also distinguishes itself from the sibling get_ad_performance_breakdown by explicitly contrasting account-level vs per-ad detail.

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

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

The description provides clear when-to-use context by framing the tool as the account-level paid-performance comparison and explicitly points to the correct alternative: "For per-ad detail use get_ad_performance_breakdown." This lets an agent route correctly without opening the sibling schema.

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

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

Annotations already provide readOnlyHint:true and idempotentHint:true, so the safety profile is covered. The description adds behavioral value by disclosing the default fallback (workspace default when no parameters are passed) and a caution about example_posts (reference only, never copy/rewrite). These details go beyond the annotations without contradicting them.

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

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

The description is three sentences with a clear structure: primary purpose, parameter selection, and a usage caution. Every sentence adds unique information with no redundancy. The key action and contents are front-loaded, making it easy to scan.

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

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

For a read-only tool with no output schema, the description lists the expected content fields (tone, words to avoid, positioning, target audience, colours, fonts, example posts), covers the default behavior, and provides a critical usage guideline for example_posts. An agent has enough information to call the tool correctly and interpret the result.

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

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

Schema description coverage is 100%, with both parameters having descriptions from list_brand_profiles and list_content_plans. The description enhances this by explaining the selection logic: 'Pass a content_plan_id... or a name... otherwise the workspace default is returned.' This clarifies the optional nature and default behavior, which the schema does not state. The added semantics materially help an agent choose parameters correctly.

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

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

The description clearly states the tool reads brand guidelines and lists the specific contents (tone, words to avoid, positioning, target audience, colours, fonts, example posts). It distinguishes itself from siblings like list_brand_profiles (listing) and set_brand_profile (writing) by using 'Read' and specifying it returns the full guidelines. The purpose is unambiguous.

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

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

It gives explicit usage context ('to write in before drafting any copy') and explains how to select a profile (content_plan_id, name, or default). However, it does not explicitly name alternatives like list_brand_profiles when you only need a list of names, though the schema references that sibling for the name parameter. The context is clear but could be more direct about when not to use this tool.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and idempotentHint=true, which cover safety and side-effect behavior. The description adds content-level detail about the metrics returned (follower growth, engagement, demographics, page views) but nothing beyond that—no auth requirements, rate limits, or pagination notes. Given the annotations, a 3 is appropriate: the description supplements but does not deeply extend the behavioral profile.

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 exactly two sentences, front-loads the purpose, and wastes no words. The primary function is stated first, followed by the data types and a direct suggestion to use a sibling tool. Every sentence earns its place, making it optimally concise and well-ordered.

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

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

For a read-only tool with no output schema, the description adequately covers what the tool does, what it returns, and how it fits into a workflow (comparison with profiles). It does not explain return format or pagination, but given the tool's simplicity and the sibling tool reference, the context is sufficiently complete for an agent to invoke it correctly. A 4 reflects minor missing details (like return shape) that are not critical.

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

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

Schema description coverage is 100%, so all four parameters (profile, organization_id, start_date, end_date) are already documented in the input schema. The description adds a hint about parameter usage ('same period as the personal profiles'), which subtly advises aligning dates, but it does not elaborate on parameter syntax or relationships beyond what the schema already provides. Baseline 3 fits.

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

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

The description states the specific resource ('company page'), the action ('fetch company page reach'), and the data fields (follower growth, engagement, demographics, page views). It also explicitly names the sibling tool 'get_profile_performance' and contrasts the two, making the purpose unambiguous and distinct from siblings.

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

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

The description gives a clear usage directive: 'Use alongside get_profile_performance to show how the team's profiles compare against the page.' It implies when to use this tool (alongside the profile performance tool) and the context (comparison). It does not explicitly state exclusions from other analytics tools, but the cited sibling is the most relevant alternative, so it earns a 4.

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

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

Annotations already declare readOnlyHint and idempotentHint, but the description adds crucial context: the influencer must personally authorize through LinkedIn's sign-in screen, and the link is stable across calls. This goes beyond the structured annotations by explaining the human-in-the-loop requirement and permanence, which an agent needs to set expectations correctly.

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

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

The description is two sentences, with the primary purpose in the first sentence and behavioral nuances in the second. No filler or redundancy. It is 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?

For a simple read-only tool with one parameter and no output schema, the description fully explains what the return value is (a URL), how it behaves (stable, requires influencer action), and the required input. An agent can correctly invoke it without missing information.

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

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

The single parameter 'influencer' is fully described in the schema ('Influencer name or influencer id (from create_influencer, list_teams or list_profiles)'), covering 100% of the schema. The description adds no extra semantics about the parameter, so the baseline 3 applies.

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

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

The description states a specific verb ('Return') and resource ('personal connect link for a team influencer'), which is unambiguous and clearly distinguishes it from sibling tools like list_profiles or create_influencer. No other tool in the sibling list targets connect links, so it is fully differentiated.

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

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

The description makes the intended use clear: retrieving the personal connect link for a team influencer. It doesn't explicitly name alternatives or exclusions, but there are no competing tools for this specific purpose among the siblings. The context is sufficient for an agent to decide when to call it.

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

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

Annotations already declare readOnlyHint: true and idempotentHint: true, covering the safety profile. The description adds concrete information about what is returned (statuses and comments), which is valuable context beyond the annotations. No contradiction exists.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently conveys the core function and return values in under 20 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 read-only tool with one parameter and no output schema, the description adequately explains what the agent will receive. It could optionally mention the structure of comments or pagination, but given the simplicity, it is sufficiently 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 input schema covers the single parameter with a description that references list_content_plans, giving the agent context on where to obtain the id. The tool description adds no further semantic detail beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb ('Returns') and a clear resource ('each post's approval status... plus comments'). It explicitly lists the status values (pending, approved, changes_requested) and the comment aspect, making it highly specific and distinct from sibling tools like share_content_plan or create_content_plan.

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 purpose implies when to use it (when you need approval statuses or client comments on a plan), but there is no explicit guidance on when not to use it or which alternatives to consider. No exclusions or alternative tool mentions are provided.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds meaningful behavioral context by explaining the company-page-only constraint and the reasoning (API does not expose engager data for personal posts), going beyond the structured fields.

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

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

Two sentences, zero filler. The core purpose is front-loaded, and the second sentence delivers a key constraint plus a pointer to the sibling source. Every sentence earns its place.

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

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

For a read-only, two-parameter tool with strong annotations, the description covers the main caveat (company page only), the input source, and implicitly the return content (comments and reactions, who engaged and said what). It could mention pagination or result shape, but there is no output schema and the tool is simple, so this is adequate.

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

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

Schema coverage is 100% and both parameters are well documented in the schema. The description reinforces that post_urn comes from list_company_posts, but adds little new semantic detail beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the verb 'Read' and the resource 'comments and reactions on a single LinkedIn COMPANY PAGE post', and it distinguishes this from personal profile posts. It also ties to sibling list_company_posts as the source for the post URN, making the tool's scope unambiguous.

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

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

Explicitly states when to use (company page posts) and when not (personal profile posts, citing API limitation), and directs the agent to list_company_posts for the required post URN. This is concrete, actionable guidance with a clear exclusion.

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

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

Annotations already declare readOnlyHint and idempotentHint, so safety is covered. The description adds behavioral context by defining each status value, including that awaiting_confirmation requires user action at a confirmation link and that failures carry an error, and published includes a permalink. This goes beyond annotations and helps an agent interpret the result and decide next steps.

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 core statement followed by a precise enumeration of statuses and a single worthwhile pointer to retry_post_channels. Two sentences with no filler; each clause adds needed 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 read tool with one parameter and no output schema, the description is complete: it lists the possible status values and their notable payloads (permalink, error), and it connects to the retry sibling. An agent can call the tool and interpret the result without missing information.

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

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

Schema coverage is 100% for post_id, which is described as coming from schedule_post, publish_to_channels or list_scheduled_posts. The description does not add any additional parameter semantics, so the baseline score of 3 applies.

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

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

States a specific verb ('Show where a post stands') and resource ('on LinkedIn and on each Facebook/Instagram channel'), enumerates the exact statuses returned, and distinguishes itself from sibling retry_post_channels by noting that failed channels are handled there. An agent can clearly tell this is the per-channel status read tool.

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

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

The description implies when to use it (to check post status after scheduling/publishing) and gives an explicit alternative for failures: failed channels can be retried with retry_post_channels. It does not, however, state when not to use it versus other read-oriented siblings like get_post_engagement or list_scheduled_posts, so the guidance is clear in context but not exhaustive.

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

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

Annotations already cover read-only and idempotent behavior. The description adds valuable contextual behavior beyond that: LinkedIn does not expose follower history for personal profiles, so only a live total is returned and no follower series or gained-count is available. This prevents an agent from expecting data that will never be present.

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

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

The description is two focused sentences with no filler. The main purpose and returned metrics are front-loaded, and the important LinkedIn limitation is stated in a separate, clearly structured sentence.

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

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

Even without an output schema, the description names the key returned categories (impressions, unique reach, video, cadence, follower count) and explicitly documents the missing follower-history behavior. For a read-only tool with simple parameters and strong annotations, this is sufficient for an agent to use it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters, including defaults for start_date and end_date. The description does not add detail about parameter usage or format, so the baseline of 3 is appropriate.

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

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

The description states a specific verb ('Fetch') and a clear resource: personal LinkedIn post performance for a connected person or team influencer. It also lists concrete metrics and the follower count, making it easy to distinguish from sibling tools like get_company_performance or get_post_engagement.

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

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

The description clearly establishes the intended context: retrieving metrics for personal profiles or team influencers, not company pages or individual posts. It does not explicitly name alternatives or give when-not-to-use conditions, but the 'personal' scope and follower-history caveat provide clear 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?

Annotations indicate readOnlyHint=false, destructiveHint=false, and idempotentHint=false, which already tell the agent this is a mutating, non-destructive, non-idempotent operation. The description adds valuable context: it explains that imports always land as drafts because the status parameter is ignored for safety, and that passing back posts from preview prevents re-reading or changing them. It also clarifies the two different input handling paths. No contradiction with annotations; the description reinforces and extends the safety profile.

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

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

The description is two sentences and packs essential information with zero waste. It front-loads the core purpose and then immediately gives the critical workflow instruction. Every sentence earns its place; there is no redundant content or filler.

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

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

Given the tool's complexity (10 parameters, nested posts object, and two distinct modes), the description is remarkably complete. It covers the core behavior, the correct sequence of operations, and the safety guarantee about drafts. It does not explain every parameter, but the schema already does that. There is no output schema, so the description does not need to explain return values. The workflow guidance is sufficient for an agent to call this tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful context beyond the schema by explaining the semantics of key parameters: the 'mode' parameter's role in detecting planning documents versus artwork, and the 'posts' parameter as confirmed/edited output from preview_canva_plan. It also clarifies that 'status' is ignored and always results in drafts, which is not fully apparent from the schema alone. This additional explanation helps the agent understand the interactions between parameters.

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

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

The description clearly states the tool imports Canva designs into a content plan and explains the two distinct outcomes: planning documents become a full schedule with copy, single creatives become artwork with AI-drafted copy. It also differentiates from the sibling preview_canva_plan by prescribing a workflow that begins with the preview. The specific verb 'import' plus the resource 'Canva designs' and the target 'content plan' make the purpose unambiguous.

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

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

The description gives explicit workflow guidance: 'Call preview_canva_plan first, show the user the copy and dates, then pass those posts back here so nothing is re-read or changed.' This tells the agent the correct sequence and that re-reading should be avoided. It also implicitly distinguishes between plan_document and artwork modes by describing both cases, though it does not explicitly state when to force one mode over the other. Overall, the usage context is clear, but it could be more explicit about exclusions or 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.

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description's burden is lighter. It adds value by disclosing the return contract (id, name, status, currency) and the dependency that the profile must be 'connected'. This is useful context beyond the structured annotations.

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

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

Two sentences with zero waste: the first states function and scope, the second states the downstream contract. Every sentence earns its place.

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

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

For a 1-parameter read-only list tool with full schema coverage and safety annotations, the description is complete. It conveys purpose, scope, returned fields, and how its output feeds sibling ads tools - nothing needed to call it correctly is missing.

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

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

Schema description coverage is 100% - the profile parameter is fully documented ('Profile name or sessionId from list_profiles.'). The description's phrase 'connected profile' reinforces parameter semantics but adds no format or syntax details beyond the schema, so the baseline 3 applies.

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

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

The description states a specific verb ('List'), resource ('LinkedIn Ads accounts'), and scope ('available on a connected profile'), plus the returned fields (id, name, status, currency). It is unambiguous against siblings like list_ad_campaigns or list_profiles, which target different resources.

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 second sentence positions the tool as the entry point for the ads tool family: 'Use the returned id as `ad_account_id` in the other ads tools.' This tells the agent when the tool fits in a workflow. It lacks explicit exclusions naming alternatives (e.g., 'use list_profiles for profiles'), which keeps it a 4 rather than a 5.

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

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

Annotations already establish readOnlyHint, idempotentHint, and openWorldHint, covering safety and idempotency. The description adds valuable behavioral context beyond annotations by specifying the exact fields returned (objective, type, status) and the practical follow-up (using campaign IDs for scoped analysis). It does not disclose potential pagination or edge cases, but the annotation coverage keeps the bar lower, making this a strong addition.

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

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

The description is two tight sentences with zero filler. The primary action and scope are front-loaded, and the second sentence adds a useful scoping hint. Every word earns its place.

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

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

For a low-complexity list tool with two parameters and no output schema, the description explains what fields will be returned (objective, type, status) and how the results can be used. It does not mention pagination or size limits, but given the read-only, idempotent, open-world annotations and the simplicity of the operation, the missing details are not critical. The description overall enables correct invocation and interpretation.

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

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

Schema coverage is 100%: both 'profile' and 'ad_account_id' have descriptive schema entries explaining their sources and defaults (e.g., 'Omit to use the first ad account'). The tool description adds no extra meaning to the parameters themselves. With full schema coverage, the baseline of 3 is appropriate.

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

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

The description specifies the exact verb ('List'), the resource ('campaigns in a LinkedIn ad account'), and the returned attributes ('objective, type and status'). This clearly distinguishes it from siblings like list_ad_accounts (accounts vs campaigns) and get_ad_creatives (creatives vs campaigns), even without naming them explicitly.

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

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

The description implies a usage context by saying 'Use campaign ids to scope ads analysis to one campaign,' which tells the agent why it might want the output. However, it does not explicitly state when to use this tool versus alternatives, nor does it name any exclusions such as 'use get_ads_performance for metrics' or 'use list_ad_accounts for account-level listing.' The guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=false, so the safety profile is covered. The description adds useful semantic context (workspace scope, one per client) but doesn't disclose behavior like pagination, ordering, or response shape. This is a reasonable but not rich addition beyond the annotations.

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

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

The description is two short sentences with no filler. The primary action and scope are front-loaded, and the follow-up tool reference is placed second for easy scanning.

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

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

For a no-parameter, read-only listing tool, the description is complete: it defines what is listed, the scope, and how to use the returned data. The openWorldHint=false annotation and idempotentHint=true further assure the agent about the result set and side effects.

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

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

There are zero parameters, and the input schema is empty, so there is no parameter meaning to add. The description still clarifies that each listed item has a 'name' usable with get_brand_profile, which gives the agent useful expectations about the output.

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

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

The description uses a specific verb ('List') and a specific resource ('brand kits saved in this workspace') and adds the 'one per client' scope. It also points to the sibling get_brand_profile, making it clear how this tool differs from the single-profile 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?

It clearly states the purpose and gives a concrete next step: 'Use the name with get_brand_profile.' It doesn't explicitly contrast against list_profiles or other listing siblings, but the workspace-scoped brand-kit framing provides sufficient 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds useful context by restricting the scope to the signed-in user and noting the Canva connection prerequisite, but it does not describe output shape, error behavior, or pagination.

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, focused sentence that front-loads the action and resource, then adds the purpose and prerequisite. There is no filler or repetition of schema details.

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

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

For a read-only listing tool with no output schema, the description covers the essential context: what is listed, whose data, why it is listed, and a key prerequisite. It does not describe the return format or pagination, but those are minor gaps for this kind of simple list operation.

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

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

Schema description coverage is 100%: both query and folder_id already have meaningful descriptions. The tool description does not add parameter-specific detail, but it does not need to since the schema documents the parameters well.

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 'List' with a specific resource: the signed-in user's Canva designs and folders. It also gives the downstream purpose ('so they can be imported into a content plan'), making it easy to distinguish from the sibling tool import_canva_designs.

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

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

The description gives context: use this when you need to list Canva designs before importing them into a content plan, and only if the user has connected Canva. However, it does not explicitly name import_canva_designs as the alternative or state when not to use this tool.

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

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

Beyond the readOnlyHint and idempotentHint annotations, the description adds meaningful behavioral context: it states which platforms are connected, what fields are returned, and crucially that only Facebook and Instagram can publish today. This helps the agent anticipate real-world constraints.

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

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

Three sentences with no filler: the first defines the listing scope and output, the second explains how to use the ids, and the third adds the key publishing caveat. The most important information is front-loaded.

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

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

For a zero-parameter, read-only list tool, the description is complete. It names the returned fields, explains how the output should be used with sibling tools, and flags platform-specific limitations, leaving no critical gap for an agent selecting or invoking it.

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

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

The tool has zero parameters and the schema coverage is effectively complete, so the baseline of 4 applies. The description appropriately focuses on the output fields rather than parameters, as there are none to explain.

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

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

The description uses a specific verb ('List'), names the exact resource ('connected social channels'), and enumerates the platforms and returned fields (channel id, platform, name, handle, status). This clearly distinguishes the tool from sibling list tools such as list_company_pages or list_profiles.

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

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

It gives clear, actionable context for downstream use: ids can be passed to publish_to_channels, schedule_post, or set_post_channels. It stops short of explicitly saying when not to use this tool versus sibling list tools, but the use cases are well specified.

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

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

Annotations already cover readOnly, idempotent, and openWorld behavior. The description adds useful context beyond annotations: access is limited to company pages a connected person can report on, and the server's data model is people-centric rather than page-centric. This helps prevent incorrect assumptions about the underlying data source.

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 focused sentences with no wasted words. It front-loads the core action and scope, then adds the key conceptual clarification about publishing from people rather than pages.

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

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

For a simple one-parameter list tool, the description combined with the full schema and annotations is largely complete. It lacks explicit details about the returned shape or identifiers, but the word 'List' and the tool's purpose make the expected result reasonably inferable.

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

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

Schema coverage is 100%, and the profile parameter is already described as 'Profile name or sessionId from list_profiles.' The description mentions 'connected person' but does not add substantial parameter-level meaning beyond what the schema already provides.

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

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

The description uses a specific verb and resource: 'List the LinkedIn company pages a connected person can report on.' It also distinguishes itself from sibling tools by clarifying that 'this server publishes from people, not pages,' preventing confusion with page-centric or post-centric list tools.

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

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

It gives a clear intended use case: benchmarking team personal profiles against company pages. It does not explicitly name alternative tools or exclusion conditions, but the context provided is enough for an agent to understand when this listing is relevant.

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

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

Annotations already disclose readOnly, open-world, and idempotent behavior, so the description is not required to repeat those. It adds useful scoping context by specifying 'organic' and 'published' posts, which clarifies the behavioral boundary. No contradiction with annotations.

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

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

The description is two sentences with no filler. The core action and resource are front-loaded, the output content is stated, and the usage guidance is concise and purposeful.

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

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

For a read-only list tool with fully documented parameters and safety annotations, the description provides enough guidance to select and invoke it. It mentions the key output dimensions (impressions, engagement) but does not fully describe the return structure—slightly mitigated by the absence of an output schema being a common pattern.

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

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

The input schema has 100% parameter description coverage, so the schema already documents parameters like start_date, end_date, profile, and organization_id. The description adds high-level context about date range and output metrics, but does not need to repeat parameter-level details.

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

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

The description names a specific action ('list'), a specific resource ('organic posts published by a company page'), and the date-range scope, while adding that each post carries impressions and engagement. The phrase 'organic posts published' also distinguishes this from scheduled or ad-post tools in the sibling list.

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

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

The description clearly states when this tool is useful: comparing company-page reach against personal posts and checking publication frequency before drawing conclusions. It gives a clear use context, though it does not explicitly state when to avoid it or name an alternative tool.

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

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

Annotations already declare readOnlyHint true and idempotentHint true, so the safety profile is covered. The description adds meaningful behavioral context about what the response includes: ownership, the associated team influencer, and the page in the app where the plan appears.

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

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

A single well-structured sentence that leads with the action and resource, then layers relevant detail. There is no filler, repetition, or unnecessary explanation.

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

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

For a zero-parameter, read-only list tool, the description fully covers what the tool returns and its scope. No output schema exists, but the description provides a sufficient high-level shape of the response without needing to enumerate fields. Pagination or sorting details would be nice but are not essential for correct invocation.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameters, and it adds no conflicting or ambiguous input expectations.

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

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

The description states a specific verb ('List'), a clear resource ('content plans'), and ownership scope ('owned by the signed-in user'). It also enriches the purpose by noting the influencer/team association and where the plan appears in the app, which distinguishes it from generic list tools.

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

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

The description implies when to use it—when the user needs their own content plans—but does not explicitly contrast it with siblings like list_scheduled_posts or list_company_posts. There is no exclusions or when-not-to-use guidance, leaving selection to inference.

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

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

Annotations already mark the operation read-only and idempotent. The description adds valuable behavior: the response is split into two groups, duplicate names resolve to the team influencer by default, and the useful fields are name, influencerId, and sessionId. No contradiction with annotations.

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

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

Three sentences, each earning its place: scope/grouping, downstream usage, and duplicate-name resolution. The key purpose is front-loaded, and the disambiguation rule is placed at the end.

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

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

Given a zero-parameter read-only tool with no output schema, the description covers everything needed to invoke and use the result: the grouping, the field names to consume, and the ambiguity rule. There is no missing prerequisite, alternative, or side effect the agent would need.

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

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

The tool has zero parameters, and the schema fully documents that with 100% coverage, so there is no parameter burden for the description to carry. Nothing more is needed.

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

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

States the exact resource ('every identity connected to this workspace') and a specific verb ('List'), then defines the two groups returned (team influencers and the user's own LinkedIn accounts). This clearly distinguishes it from sibling list tools such as list_teams or list_brand_profiles.

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

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

Gives clear downstream context: the returned name, influencerId, or sessionId are meant to be passed as the `profile` argument of other tools, and team influencers are the usual target for content plans. It does not explicitly name alternative tools or exclusion conditions, so it stops short of full when/when-not guidance.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=false, and the description's 'List' is consistent with a safe read operation. The description does not add extra behavioral details such as pagination, ordering, or whether only scheduled-status posts are returned, but the annotations reduce the burden.

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

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

The description is one concise sentence that front-loads the action and mentions the relevant output fields. Every word earns its place, with no redundant phrasing.

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

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

For a one-parameter, read-only list tool, the description sufficiently covers the return fields and implies the prerequisite ID source. The title says 'scheduled posts' while the description says 'posts in a content plan', leaving minor ambiguity about whether all posts or only scheduled ones are included, but overall the definition is adequate.

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

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

The single parameter content_plan_id is fully documented in the schema with 'Plan id from list_content_plans', giving 100% schema coverage. The description itself does not add detail about the parameter beyond relating it to 'a content plan', so the baseline score applies.

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

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

The description uses a specific verb and resource: 'List the posts in a content plan' with dates, status, and text. This clearly differentiates it from list_content_plans, which lists plans rather than posts, though it does not explicitly name any sibling alternatives.

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

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

Usage context is implied through the parameter note 'Plan id from list_content_plans', which signals a prerequisite call. However, there is no explicit guidance about when to use this tool versus alternatives like list_company_posts or schedule_post, so the agent must infer the intended workflow.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds valuable context about the returned data (members, connection status, unassigned influencers), going beyond a bare 'list' and giving the agent an accurate expectation of the output.

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

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

Two sentences with no wasted words. The primary action is front-loaded, and the details about members, connection status, and unassigned influencers are packed 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 zero-parameter read-only list tool, the description fully specifies what is returned (teams, members, connection status, unassigned influencers) and the practical use cases (finding team IDs, identifying who needs LinkedIn connection). No output schema is needed because the description covers the return content.

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

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

The tool has zero parameters, so there is nothing to explain. The schema coverage is effectively 100% (empty schema), and the baseline for a no-parameter tool 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 states a specific verb (List), a specific resource (teams on the influencers page), and details what is included (members, connection status, unassigned influencers). It clearly distinguishes this from sibling tools like list_profiles or list_company_pages by focusing on team membership and connection status.

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

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

The description gives clear context for when to use it: 'Use this to find team ids and to see who still needs to connect LinkedIn.' However, it does not explicitly mention alternatives or when not to use it, so it falls short of a 5.

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

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

Annotations already cover readOnlyHint and idempotentHint, so the bar is lower. The description adds value by disclosing what the tool returns in detail (whether it is a planning document, client/goal/frequency, posts with proposed dates) and by explicitly stating 'Nothing is written.' This goes beyond the annotations by describing the tool's inspection and validation 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 two sentences with zero filler. The first sentence front-loads the action and return contents; the second sentence states safety and usage order. Every clause earns its place.

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

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

Given no output schema, the description adequately explains the return contents. It also covers the core use case (confirming copy before import) and safety. With only 1 required parameter and full schema coverage, nothing essential is missing for an agent to call this tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add significant parameter-level detail beyond the schema; 'proposed date' loosely maps to start_date, but no new syntax or examples are given. The schema already documents design_ids and start_date sufficiently.

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 ('Read') and resource ('Canva design'), then enumerates the exact return contents (planning document flag, client/goal/frequency, post copy and proposed date). It also distinguishes itself from sibling import_canva_designs by stating 'Use this before import_canva_designs', making the tool's unique role clear.

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 this tool: 'Use this before import_canva_designs so the user can confirm the copy and schedule.' This names the alternative tool and gives a precise condition, leaving no ambiguity about sequencing or purpose.

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 thoroughly discloses behavior beyond the annotations: it never publishes by itself, returns 'awaiting_confirmation' plus a confirmation link, all accounts default unticked, and the agent cannot confirm on the user's behalf. This gives the agent a precise mental model of the tool's safety and interaction semantics, which the annotations alone do not provide.

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

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

The description is front-loaded with the core action and then systematically explains the confirmation flow and agent obligations. Every sentence earns its place, including the SAFETY block which compresses critical behavioral rules into scannable bullets. Length is justified by the tool's safety-sensitive nature.

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

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

Given there is no output schema, the description explicitly states the return status and confirmation link. It also covers all user-facing steps, agent instructions, the default state of accounts, and the limit on agent authority. For a tool with one parameter and this safety profile, 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 input schema already documents post_id as 'Post id from list_scheduled_posts' with 100% coverage. The description adds context about the post being in a content plan and attached channels, but it does not elaborate on the post_id parameter itself or its format beyond what the schema states, so it meets the baseline without extra value.

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

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

The description opens with a specific verb and resource: 'Ask to publish an existing post in a content plan now' and names the target channels (LinkedIn, Facebook/Instagram). This clearly distinguishes it from scheduling tools and other publish tools, while the phrase 'Ask to' signals the confirmation-based flow that defines this tool.

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

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

The description provides rich usage context: it explains the confirmation flow, tells the agent to instruct the user to open the link and tick accounts, and warns against treating 'all accounts' as blanket consent. However, it does not explicitly name sibling tools (e.g., publish_to_channels, schedule_post) or state when to prefer one over the other, so it stops short of full when/when-not guidance.

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

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

The SAFETY section clearly discloses the confirmation-gated behavior: nothing goes live until the user opens the confirmation link and ticks accounts, all accounts are unticked by default, and the agent cannot confirm on the user's behalf. This goes well beyond the annotations and is essential for correct invocation.

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

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

The description is front-loaded with the core operation, then platform rules, then the safety-critical instructions. Although long, every sentence carries necessary operational or safety information, and the structure groups related constraints logically.

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

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

For a complex publishing tool with no output schema, the description covers the necessary media constraints, scheduling semantics, return status/confirmation link, and the agent's required user-handoff behavior. There are no obvious gaps that would prevent an agent from invoking it correctly.

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

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

Even though schema coverage is 100%, the description adds substantial meaning: media_urls must be public HTTPS, Facebook limits (1-10 images or one video), Instagram media requirements and Reels behavior, caption limits (2200 chars/30 hashtags), and what happens when scheduled_at is omitted. This materially clarifies how to fill the parameters correctly.

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 leads with a specific action ('Publish (or schedule) a post') and names the target resources (Facebook Pages, Instagram Business accounts), and it explicitly separates itself from the sibling 'schedule_post' for LinkedIn. It also details platform-specific post types, so an agent can immediately tell what this tool is for.

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

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

It gives concrete when-to-use guidance: use it for Facebook/Instagram publishing or scheduling, omit scheduled_at to publish now, pass it to schedule, and route LinkedIn needs to schedule_post with channel_ids instead. The prerequisite to use upload_media/create_upload_link for public HTTPS media is also spelled out.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, so the mutation risk is known. The description adds meaningful behavioral guarantees: only failed channels are retried, and already-published channels are never re-posted, which prevents duplicate posts. It does not mention side effects like rate limits or partial failure behavior, but the non-repost guarantee is strong 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, front-loaded with the core action, and no filler. Every phrase adds useful information: the action, the channel scope, the optional filtering behavior, and the anti-duplicate guarantee.

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

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

Given only two parameters and no output schema, the description covers the critical invocation details: which post, which channels, and the safety guarantee about not re-posting published channels. It could be slightly stronger by explaining what happens if there are no failed channels or what the response contains, but it is sufficient for correct use.

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

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

Schema description coverage is only 50%: channel_ids is described in the schema, and the description reinforces it by explaining it can target specific channels. However, post_id has no description in either the schema or the tool description, so the agent must infer its meaning from the parameter name 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 names a specific action ('Retry publishing'), a specific resource (a post), and a precise scope ('failed Facebook/Instagram channels'). It also states a key exclusion ('published channels are never re-posted'), which distinguishes it from broader tools like publish_post_now or publish_to_channels.

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

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

The description gives clear context: use this when a post had failed channels and you want to retry them now. It also clarifies the optional channel_ids behavior, but it does not explicitly name alternatives or 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.

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

The description carries the full burden since annotations only say readOnlyHint=false and destructiveHint=false. It goes far beyond: 'this never publishes or schedules by itself', returns 'awaiting_confirmation' with a link, all accounts default unticked, and the agent cannot confirm on the user's behalf. This is exactly the kind of non-obvious behavior an agent must know, and it does not contradict the annotations.

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

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

Long (~250 words) but every block earns its place for an 11-parameter tool with a non-obvious confirmation flow: media rules, mention syntax, and safety instructions are all essential. It is front-loaded with purpose and ends with the critical safety workflow. Slightly dense, but not padded.

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

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

For a complex tool with 11 parameters and no output schema, the description covers everything needed to call it correctly: id sourcing, media constraints, cross-posting, timezone/default time handling, return status ('awaiting_confirmation' + link), and mandatory user-facing instructions. Nothing an agent needs to invoke it safely is missing.

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

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

Schema coverage is 100%, setting baseline at 3, but the description adds real value beyond the schema: the @[Full Name](urn:li:person:ID) mention syntax, which sibling tools provide which ids, the 'never invent an id' rule, the PDF-cannot-mix-with-other-media constraint, and the default-unticked confirmation behavior. It supplements rather than merely restates 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?

Opens with a specific verb+resource ('Add a post to a content plan'), and the status explanation (scheduled vs draft) immediately separates it from siblings like publish_post_now, update_post, and delete_post. The safety disclosure also clarifies that despite the name it only creates a pending confirmation, not an actual 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?

Gives rich, explicit usage context: when to use 'draft' vs 'scheduled', the exact mention syntax with id sources (list_profiles, list_company_pages), when to pass channel_ids (from list_channels), and a mandatory safety workflow ('always tell the user to open the link'). It stops short of explicitly naming alternatives like publish_post_now for immediate publishing, so exclusion guidance is implied rather than stated.

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

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

The description adds meaningful behavioral detail beyond the annotations: it discloses upsert semantics ('only the fields you pass are changed') and the non-obvious side effect that setting is_default true removes the default flag from other profiles. This is exactly the kind of context an agent needs and does not contradict readOnlyHint=false or idempotentHint=true.

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

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

Three dense sentences with no filler: purpose, patch semantics, and the default-flag caveat. Every sentence earns its place and the most important behavioral constraint 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 rich schema, annotations, and the description's explicit coverage of create-vs-update, partial patching, content-plan linking, and default uniqueness, the agent has what it needs to invoke the tool correctly. The main omission is the return value, and with no output schema that is a minor gap rather than a correctness risk.

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 descriptions already cover all 10 parameters at 100% coverage. The description adds cross-cutting parameter semantics beyond the schema: name is the upsert key, all other fields are optional patch fields, and is_default and content_plan_id carry behavioral side effects that their individual schema entries do not fully convey.

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

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

The description clearly states what the tool does: it saves a client's brand guidelines and creates or patches a brand profile by name. This distinguishes it from sibling read tools like get_brand_profile and list_brand_profiles without requiring the agent to inspect schemas.

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

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

The description gives clear context for when to use it: to make future copy sound like a client's brand and optionally attach the profile to a content plan. It does not explicitly name alternatives or state when not to use it, but the purpose is specific enough that routing is unambiguous.

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

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

Annotations only cover readOnly/openWorld/idempotent/destructive hints; the description adds critical behavior: replaces previous unpublished channel list, pauses scheduled posts until re-confirmation, returns 'awaiting_confirmation' with a link, and all accounts are unticked by default. It also discloses that confirmation cannot be done on the user's behalf, which is exactly the kind of context annotations do not provide.

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

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

Front-loaded with the core action, then organized into replacement behavior, constraints, draft/scheduled differences, and safety. The safety instructions are repeated in slightly different forms but each sentence adds operational guidance for the agent, so the length is justified.

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

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

For a complex tool with no output schema, the description is remarkably complete: it covers prerequisites, return status, confirmation flow, account ticking defaults, and the draft/scheduled distinction. Nothing an agent needs to decide whether and how to call it correctly is missing.

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

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

Schema description coverage is 100%, so baseline is 3, but the description adds meaningful parameter behavior: passing an empty channel_ids list means LinkedIn only, and Instagram requires media, max 2200 chars, and 30 hashtags. It doesn't elaborate on text_overrides or link, but the schema already documents those.

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

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

States a specific verb ('Set') and resource ('which connected Facebook/Instagram channels an existing post also goes out to'), with source of IDs, and distinguishes from publish/schedule by clarifying it only sets channels on an existing post. The title 'Choose extra channels for a post' aligns, and the description makes the tool's role unmistakable.

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

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

Provides clear context: use for existing posts, with channel ids from list_channels, and explains draft vs scheduled behavior. Does not explicitly name alternatives like publish_to_channels or when not to use it, but the safety line ('never publishes or schedules by itself') gives enough guidance.

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

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

The description explicitly says 'Creates (or returns)' which aligns with the idempotentHint annotation and tells the agent the call may return an existing link rather than fail. It also reveals that the link is public and that clients can approve, request changes, and comment, adding behavioral context beyond the readOnly/destructive hints. No contradiction with annotations.

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

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

A single, front-loaded sentence packs the primary action ('Creates or returns'), the output type (public link), and the client-facing capabilities without filler. Every phrase earns its place.

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

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

For a one-parameter tool with no output schema, the description conveys what is returned (a link) and the workflow it enables. It could be slightly more explicit about the exact response shape or prerequisites, but nothing critical is missing for an agent to invoke it correctly.

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

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

The only parameter, content_plan_id, is fully described in the schema as coming from list_content_plans, so schema coverage is 100%. The description doesn't add format or source details beyond what the schema already provides, which meets the baseline but doesn't exceed it.

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

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

The description states a specific verb+resource: 'Creates (or returns) a public link' for client review of a content plan. It goes beyond the name by explaining the client-facing workflow (approve, request changes, comment), which clearly distinguishes it from sibling tools like get_plan_feedback or preview_canva_plan.

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

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

The description makes the intended use case clear: when you need a client-accessible link for reviewing and approving LinkedIn-formatted posts. It does not explicitly name alternatives or exclusion conditions, so it stops short of a 5, but the context is strong enough for an agent to decide when to call it.

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

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

Beyond the annotations (readOnlyHint=false, idempotentHint=true, destructiveHint=true), the description discloses the tool's most important behavioral trait: it never publishes or schedules by itself, returns status 'awaiting_confirmation' plus a confirmation link, and requires the user to open the link and tick each account. It also warns the agent not to treat 'all accounts' as blanket approval and not to confirm on the user's behalf. This far exceeds the baseline set by the annotations.

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

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

The description is dense and front-loaded with the core purpose, then adds media rules, an alternative, mention syntax, and a clearly labeled SAFETY section. Every sentence carries useful information, but the block is long and could be tightened or lightly structured to make the safety instructions and media constraints easier to scan. Still, there is no filler.

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

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

For an 8-parameter mutation tool with no output schema, the description is unusually complete. It explains the output shape (status 'awaiting_confirmation' plus confirmation link), the user confirmation step, media type behavior, mention requirements, and the non-published precondition. Together with the annotations, an agent has everything necessary to invoke the tool correctly and to communicate the required next step to the user.

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

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

The input schema already documents most parameters (75% coverage), and the description adds meaningful rules not in the schema: media composition limits (up to 9 images, one MP4/MOV, one PDF, no mixing PDF with other media), the special meaning of status='scheduled' (requires user confirmation), and the inline mention syntax with real ID requirements. One parameter, timezone, remains effectively undocumented by both schema and description, which prevents a 5.

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

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

The description states a specific verb and resource ('Edit the copy, date, time, status or media of an existing post') and adds an important scope restriction ('that has not been published yet'). It distinguishes this tool from siblings like schedule_post, publish_post_now, and upload_media by focusing on existing, unpublished posts and even points to upload_media for a different workflow. An agent can accurately select this tool without opening the schema.

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

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

The description gives explicit when-to-use context: the post must already exist and be unpublished. It also names a concrete alternative ('To add a single new file to a post in one step, use upload_media with attach_to_post_id instead') and tells the agent where to get mention IDs (list_profiles, list_company_pages) while forbidding invented IDs. This is strong routing guidance relative to the sibling set.

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

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

The description discloses a large amount of behavioral context beyond annotations: size limits, allowed formats, attachment semantics, and the fact that a PDF must be the only attachment. However, it introduces a contradiction with the input schema (description says 32KB max, schema says 5MB max). This confusion reduces the transparency score, as it can mislead an agent about actual constraints.

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

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

The description is dense but every sentence adds necessary operational detail: purpose, size constraint, allowed types, attachment behavior, and the sibling alternative. It is front-loaded with the core purpose and then builds specifics. No fluff.

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

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

For a tool with 4 parameters and no output schema, the description covers the return value (public URL), input encoding, size limits, allowed types, and attachment behavior. It also routes to create_upload_link where appropriate. Nothing critical is missing.

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

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

Schema coverage is 100%, so the parameters are documented. The description adds value by clarifying the base64-encoding expectation, allowed file types, and the attach_to_post_id append behavior. But it also contradicts the schema's size limit for content_base64, which is a negative factor. Net it adds more than it detracts, so a 4 is appropriate.

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

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

The description clearly states the tool's purpose: upload a small file and return a public URL for media_urls on schedule_post or update_post. It explicitly distinguishes itself from the sibling create_upload_link by noting that for normal files the agent should use that alternative. This is specific and unambiguous.

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

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

The description gives explicit usage conditions: hard size limit of 32KB decoded, allowed file types, and when to switch to create_upload_link (any normal photo, video, or carousel PDF). It also explains the attach_to_post_id behavior. This is exemplary routing guidance.

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