Socializioz — AI Social Media Manager

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

Annotations already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered. The description contributes the non-obvious scheduling fallback chain, which materially affects the outcome of a call; it does not restate the destructive/idempotent traits, leaving a minor gap on irreversibility.

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 dense sentences, front-loaded with the core action and state precondition, followed by the scheduling resolution rule. No filler and every clause changes how an agent would invoke it.

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 3-param mutation with full schema coverage and full annotation coverage and no output schema, the description covers the state precondition and the scheduling semantics well. What remains unstated is the effect on publication state beyond scheduling and any revert path, a small gap for a destructive operation.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real semantic value for schedule_at by defining the resolution order: explicit schedule_at wins, otherwise an existing schedule is reused, otherwise ASAP. That behavior is not derivable from the schema's terse 'Optional ISO 8601 time' note.

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

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

States a specific verb and resource ('Approves a PENDING_APPROVAL post') plus the secondary effect ('and schedules it'), which cleanly separates it from siblings like invoke_schedule_post, invoke_publish_now, and invoke_reject_post. The state precondition (PENDING_APPROVAL) further pins down exactly what this operates on.

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 PENDING_APPROVAL precondition gives a clear condition under which this tool applies, which is more than most siblings offer. It stops short of explicitly naming alternatives (e.g., invoke_reject_post for denial, invoke_schedule_post for already-approved posts), so no exclusion guidance is present.

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 declare the generic mutation profile (readOnly=false, destructive=false, non-idempotent, open-world), so the description carries the real burden and delivers: size ceilings per media type (20MB images, 50MB videos, 2MB decoded base64), mode precedence, and explicit failure guidance against retry loops. It does not state what happens on partial failure, whether the post must be unpublished/approved, or what the call returns.

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, and the primary action plus its draft constraint are front-loaded before the size limits and the fallback rule. Every clause carries a constraint an agent would otherwise guess at.

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 7-parameter mutation tool with a nested object and no output schema, the description covers the operational essentials: valid input modes, size ceilings, fallback rules, and retry/compression prohibitions. It stops short of describing the success response or where the resulting asset ordering lands, which an agent may want given the sibling reorder 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 baseline is 3, but the description adds meaning the schema lacks: per-type size limits, the precedence of asset_ids/file_url over base64_data, and that base64 is image-only and fallback-only. It does not explain the relationship between the nested 'file' object and the flat file_url/filename fields, which remains ambiguous across 7 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?

Names a specific verb and resource ('Attach media to a DRAFT') and constrains the target to a draft, which separates it from publish/schedule operations. It does not explicitly name the sibling operations it is adjacent to (detach, reorder, import_media_from_url), so an agent must infer differentiation from the name alone.

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

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

States the precondition (target must be a DRAFT) and establishes a preference order across input modes: Asset IDs or a real HTTPS URL first, with Inline Base64 described as an 'optional 2MB image fallback only.' It adds a negative instruction against compressing or retrying unresolved file references, but never points to a sibling tool such as media preflight for validation of an unresolved reference.

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 and idempotentHint, and the description adds useful behavioral nuance: the post and its media are preserved even though the scheduled action is canceled. It does not disclose permission requirements or status transitions, but the annotations lower the burden and there is no contradiction.

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

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

A single sentence with no filler: the action is front-loaded, the resource is specific, and the deletion caveat is an essential qualifier rather than extra verbosity.

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

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

For a simple two-parameter operation with no output schema and no nested objects, the description plus annotations and schema provide enough to invoke the tool correctly. It could mention state prerequisites or what happens after cancellation, but that is a minor gap given the tool's simplicity.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds little parameter-specific detail, but the schema already clearly documents post_id and request_id, including the client correlation id purpose.

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 ('cancels') and resource ('a scheduled post'), and adds a clarifying negative scope ('without deleting it or its media'). This makes the tool's purpose immediately clear and distinguishes it from schedule/reschedule and deletion-related operations.

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

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

The description provides no guidance on when to prefer this tool over related siblings such as invoke_reschedule_post, invoke_schedule_post, or invoke_publish_now. It implies use for scheduled posts but does not state conditions, prerequisites, or alternatives.

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

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

Annotations already signal a destructive write, and the description adds meaning beyond that: the result is a DRAFT post, and downstream lifecycle steps are not triggered. It does not fully articulate what happens to the original plan item, but it is not tautological or misleading.

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 succinct sentences carry the key facts: the transformation and the fact that downstream steps stay separate. No filler or repetition.

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

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

For a simple 2-parameter, no-nested-object mutation, the description is mostly complete: it states the state change and boundary. Most missing context is already covered by the annotations and the schema.

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

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

Schema coverage is 100%, so parameters are already well described. The tool description does not materially add to the parameter meaning, particularly around the optional `social_account_id` and what happens if it is omitted.

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: it 'converts' a 'campaign plan item' into a 'DRAFT post'. It clearly distinguishes itself from publish/schedule/approval by explicitly stating those remain separate.

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 provides a clear boundary: approval, scheduling, and publishing are not part of this operation. It does not explicitly name a sibling to choose instead, but it clearly communicates when not to expect the other downstream steps.

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 states only that a campaign is created in a workspace, which is a high-level effect but adds little beyond the tool name and annotations. It does not disclose side effects, return value, prerequisite conditions, or non-idempotency, and the available annotations (readOnlyHint false, destructiveHint false) do little to fill that gap.

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

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

The description is short and front-loaded with the action, with no filler language. However, it is under-specified for a 10-parameter creation tool; brevity here crosses into thinness rather than optimal conciseness.

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

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

Given 10 parameters, no output schema, and a mutating behavior, the description is far too sparse. It does not explain what happens after creation, what the created resource actually contains, or what minimum inputs beyond name are needed in realistic multi-workspace environments.

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

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

The schema covers 100% of parameters with clear descriptions, so the tool description does not need to repeat them. However, the description adds no extra semantic value or clarifying relationships between parameters, e.g., how workspace_id or primary_social_accounts interact.

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 ('Creates') and names a clear resource and scope: a campaign in a workspace. It does not explicitly differentiate itself from siblings like invoke_create_campaign_plan_item or invoke_update_campaign, but the core 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?

There is no guidance on when to use this tool versus alternatives such as invoke_create_campaign_plan_item or invoke_update_campaign. The only contextual hint about workspace_id being required when multiple workspaces exist is buried in the schema, not in the description.

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 aligns with annotations: readOnlyHint=false and destructiveHint=false, consistent with a non-destructive create. It does not go beyond that to mention duplicate behavior, return value, or whether plan items are created in a pending/draft state, so the added behavioral context is limited.

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

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

The description is a single clear, front-loaded sentence with no filler or redundant restatement of the tool name. It immediately conveys the core operation and target resource.

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

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

Given the simple create operation, the schema covers all five parameters in depth, and annotations are explicit, the description is largely sufficient for selecting and invoking the tool. The main minor gaps are no guidance about the return value and no explicit statement about duplication or required state, but these are small in the absence of an output schema.

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

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

Schema description coverage is 100%, so the schema already explains all parameters clearly. The description paraphrases 'content idea' and 'brief', which loosely aligns with the title and description parameters, but it adds no new meaning beyond what the input schema provides.

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

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

The description names a specific action ('Adds') and an exact resource ('a content idea or brief to a campaign plan'). It distinguishes the tool from sibling create/update operations such as create_campaign, update_campaign_plan_item, and convert_plan_item_to_post.

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

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

No explicit usage context is provided. The description does not explain when to choose this tool over update_campaign_plan_item, list_campaign_plan_items, or convert_plan_item_to_post, nor does it mention prerequisites such as an existing campaign.

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 this is a write operation. The description adds behavioral context: it is scoped to one connected account, it does not publish content, and passing client_request_id prevents duplicate drafts. No contradiction with the annotations is 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 compact and front-loaded: one sentence defines the operation and scope, and one follows up with prerequisites and idempotency. There is no wasted 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 tool with 10 parameters and a nested youtube_settings object, the description plus 100% schema coverage is adequate. It does not describe output shape or explicitly route to follow-up tools like update_draft_post or publish_now, but the agent has enough to invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds a useful combined-content requirement ('plus text or assets'), but most parameter meaning is already carried by the schema, including client_request_id's idempotency behavior.

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

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

States a specific verb and object ('Creates a DRAFT') and the resource scope ('one connected account'). The word 'DRAFT' clearly distinguishes this from publishing, scheduling, or approving 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?

It gives clear context: the call creates only a draft for one connected account, and requires a social_account_id plus text or assets. It also mentions the client_request_id deduplication mechanism, though it doesn't explicitly name sibling tools such as update_draft_post or schedule_post.

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

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

Annotations already state destructiveHint=true and readOnlyHint=false, so the description carries less burden. It nonetheless adds useful context by clarifying the destructive scope: only selected attachments are removed; the underlying Asset records are kept. This prevents an agent from assuming the assets themselves are deleted.

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

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

The description is a single well-formed sentence with two clauses, both of which carry essential information: the operation ('Removes selected attachments') and its key behavioral caveat ('Asset records stay in the library'). It is front-loaded and contains 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 an operation with only two primitive parameters, no output schema, and a clear high-level effect, the description plus annotations fully cover the necessary behavior. The library-preservation caveat fills the main possible misunderstanding around destructiveness. No additional return format or failure details are required at this complexity level.

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

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

Schema description coverage is 100%, and both post_id and asset_ids are documented in the schema with straightforward descriptions. The tool description adds no new parameter-level meaning, but because the schema fully covers both params, a baseline 3 is warranted.

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

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

The description explicitly says 'Removes selected attachments', giving a specific action and resource, and immediately clarifies that the Asset records remain in the library—distinguishing this detach operation from an asset deletion or from adding assets. This makes its purpose unambiguous even among sibling tools like invoke_attach_assets_to_post.

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

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

The description implies the usage context: use this when you need to remove assets from a post while preserving them in the library. However, it never explicitly contrasts this with the attach/reorder siblings or states when not to use it. No exclusions or alternatives are mentioned.

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 fully cover the behavior that matters most: readOnlyHint=true, idempotentHint=true, and destructiveHint=false make it clear this is a safe read operation. The description adds a small additional behavior by listing 'core-profile completeness', suggesting the result includes a completeness assessment beyond just raw attributes. It does not contradict annotations, but it does not deeply disclose edge-case behaviors such as what happens when no brand profile 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 focused sentence, efficiently listing the profile components without elaborate background or irrelevant detail. It is front-loaded with the core content ('Brand identity, audience, voice, goals...') and is appropriately sized for a simple read tool. The only reason not to award 5 is that rewording into an explicit verb-based sentence would make its purpose even clearer.

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

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

With only two optional parameters, no output schema, and strong annotations, the description covers the essential domain of the call. It is missing some contextual information that would make it fully self-sufficient, such as what the response looks like, whether a brand profile can be absent, and how workspace_id behaves when multiple workspaces exist despite not being schema-required. For a simple read-only retrieval tool, this is adequate but still has gaps.

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

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

Schema description coverage is 100%, so the description is not required to explain the parameters in depth. The 'workspace' scope in the prose aligns with workspace_id, and request_id is adequately described in the schema as an echo/tracing field. The description adds minimal meaning beyond the schema, which is acceptable given the high schema coverage.

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

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

The description clearly identifies the tool as returning the brand profile for a workspace, enumerating the exact content areas: identity, audience, voice, goals, guidelines, and completeness. It is distinguishable from sibling tools like invoke_get_user_profile and invoke_get_workspace_context because it is specifically scoped to brand data. However, it omits a verb such as 'retrieves' or 'returns', so the action is inferred from the tool name, not the description.

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

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

The phrase 'for one workspace' implies the tool is for retrieving brand-level data for a specific workspace, which contextually distinguishes it from user-level or asset-level getters. It does not explicitly state when to use it versus invoke_get_workspace_context or invoke_get_user_profile, nor does it mention any exclusions. The guidance is mostly implicit, so it earns a mid-range score.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is fully covered. The description adds that it serves guides and that an enabled tool name may be passed, but that dual-mode detail is also restated in the schema, and nothing is said about the shape or breadth of what is returned.

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

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

A single sentence with the human-facing framing front-loaded before the topic enumeration. It reads as a fragment rather than a sentence, but no words are wasted and the list earns its length by serving the undocumented enum.

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 lookup with annotations covering the safety profile and no output schema, the main thing an agent needs is the set of valid topics, which is provided. What the help response actually contains and when to reach for it are still left unstated, so it is not fully closed.

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 there is only one parameter, so the baseline is 3. The description goes beyond it by effectively supplying the missing enum — twelve named topic values plus the 'exact tool name' mode — which the schema does not encode anywhere.

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 label 'Beginner-to-publish guides' plus the name 'Get MCP Help' make it inferable that this returns documentation, but the description never actually states what the tool does with the topic — it is essentially a value list. An agent can guess the purpose, but it is implied rather than stated.

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?

Calling a help tool when documentation is needed is a strong implicit signal, and no sibling provides help so there is no alternative to disambiguate against. However, the description gives no explicit trigger ('use before invoking unfamiliar tools', 'when a call fails') and no guidance on how topic names should be chosen.

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=true, idempotentHint=true, destructiveHint=false. The description aligns with those and adds only a slightly richer notion of returning 'current action flags,' but it does not disclose any other behavioral traits like authentication needs, possible errors, or post not-found behavior. It adds some context beyond annotations but not substantial detail.

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

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

One concise, front-loaded sentence that exactly identifies the operation and scope. No filler or redundant phrases. The information earns its place.

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

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

For a simple read-only getter with one required parameter and fully described schema and annotations, the description is largely sufficient. The only missing contextual piece is an explicit link to the sibling list_posts operation for broader post retrieval scenarios, but that falls more under usage guidance than completeness.

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

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

Schema description coverage is 100%, and each parameter (post_id, request_id) already has a clear description. The tool description does not add supplementary meaning to the parameters, but the baseline schemas and schema descriptions carry the burden effectively.

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 exact verb/resource: 'Returns full details and current action flags for one post.' This is specific and clearly distinguishes it from listing or mutating posts. However, it does not explicitly name or route around the sibling list_posts tool, so it lacks the explicit sibling differentiation that would earn a 5.

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

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

The description implies 'use this when you need details for a specific post,' but it does not give explicit guidance on when to use this tool instead of alternatives like list_posts or other post-related operations. No when-not-to-use conditions or alternative tool references 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 readOnly/idempotent/non-destructive/closed-world, so the safety profile is covered. The description adds real behavioral value beyond that: the returned data categories and the conditional workspace-listing behavior when no workspace_id is supplied. It does not cover rate limits or full return shape, keeping it short of a 5.

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

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

Front-loaded with 'Start here,' then a tight catalog of returned data, then the branching rule in one clause. No filler; every phrase informs invocation or interpretation.

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

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

No output schema exists, so the description compensates by naming what the call returns (user, plan, credits, brand/account summaries, capabilities) and how workspace ambiguity is resolved. Adequate for an entry-point read tool whose annotations cover safety; minor gap in not describing the shape of the workspace list beyond id/name/role is acceptable.

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

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

Schema description coverage is 100%, so both parameters are already documented, including workspace_id being conditionally required. The description repeats that condition and adds the listing/ask flow, but request_id is untouched; this is a baseline 3 where the schema does the heavy lifting.

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 concrete verb+resource (gets the user profile) and enumerates what it surfaces: user, plan, Creative Credits, brand/account summaries, capabilities. 'Start here' further frames it as an entry-point lookup, which helps distinguish it from deeper siblings like get_workspace_context or get_brand_profile, though it never names those alternatives directly.

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?

'Start here' is an explicit when-to-use directive, and the description details the multi-workspace branch (list workspaces, ask the user, then pass workspace_id). It lacks explicit 'instead use X' routing to siblings, but the sequencing guidance is strong and actionable.

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

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

Annotations already declare readOnly, idempotent, closed-world, non-destructive, so safety is covered. The description adds real behavioral context beyond them: the parameter is conditionally required, and a failed call returns an error enumerating the available workspaces by name, which tells the agent how to recover. It omits pagination/refreshed-ness details, keeping it short of a 5.

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

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

Two tight sentences with no filler; the return-value inventory is front-loaded and the conditional parameter rule follows. Slightly clipped to the point of reading as a fragment, but nothing is wasted.

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

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

With no output schema, the description does the work of previewing the response fields, which is the right instinct. But entries like 'capabilities' and 'readiness' are undefined, so an agent cannot tell what shape that data takes or whether the call is cheap enough to call routinely.

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 documented in the schema, including the request_id tracing field. The description only restates the workspace_id conditionality, adding no new syntax, format, or default information, 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 enumerates exactly what the call returns — role, readiness, plan, Creative Credits, account/post counts, capabilities — which distinguishes it from siblings like invoke_get_user_profile and invoke_list_connected_accounts. It is a noun list rather than a verb+resource sentence, but combined with the title 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?

The description gives a conditional instruction for workspace_id ('pass when multiple workspaces exist') and reveals the fallback error behavior, which is useful. However, it never says when to reach for this tool versus invoke_get_user_profile, invoke_list_connected_accounts, or invoke_list_user_workspaces — usage is only implied.

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

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

The description adds valuable behavioral detail beyond the annotations: it discloses downloading, validation, storage upload via Core.UploadFile, Asset creation, and the returned Asset ID. This is more transparent than simply stating 'imports media.' It does not discuss failure behavior or idempotency, but annotations already signal that the operation is not idempotent, softening that gap.

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

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

A single, information-dense sentence that front-loads the core purpose and separately lists the side effects and return value. There is no filler or redundant restating of the tool name.

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

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

For a tool with one required parameter, high schema coverage, and a clear side-effect chain, the description covers what matters: input type, behavior, destination, and return value. The absence of an output schema is compensated by stating the returned Asset ID. No critical context is missing.

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

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

Schema description coverage is 100%, so the schema already documents url, filename, and workspace_id adequately. The description adds a small amount of semantic context (e.g., public HTTPS for url and importing into a workspace), but it doesn't significantly go beyond the structured schema information. Baseline 3 is appropriate.

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

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

The description names a specific verb ('Imports'), a specific resource (public HTTPS image/video), and the complete pipeline (download, validate, upload, create Asset, return ID). This clearly distinguishes it from asset retrieval or listing tools like invoke_get_asset and invoke_list_workspace_assets.

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

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

The description clearly conveys when to use the tool: when a public HTTPS image/video needs to be brought into Socializioz as an Asset. It also adds a meaningful constraint (public HTTPS URL). It does not explicitly name alternatives or exclusion cases, so it falls slightly 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description only notes pagination, which adds minimal behavior not already evident from annotations, but does not burden the agent with hidden side effects.

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

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

One clean sentence with no filler. The verb, resource, and pagination feature are front-loaded, making the description quick to parse and exactly as long as needed for a simple list operation.

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 straightforward read-only list operation with full parameter schema coverage and safe annotations, this is largely complete. It does not describe the response structure or next_offset semantics in the description, but the schema covers the necessary fields and no output schema exists.

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?

Since schema description coverage is 100%, all three parameters (campaign_id, limit, offset) already have clear meanings. The description adds no parameter-level detail beyond what the schema provides, 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 ('Lists') and resource ('campaign content-plan items'), which clearly distinguishes it from sibling tools like list_campaigns and list_posts. It also mentions pagination, making the purpose concrete.

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

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

The description implies when to use the tool—when you need to list campaign plan items—but it does not explicitly state alternatives or exclusions. It lacks guidance such as 'use this instead of list_posts' or any conditions, leaving some routing decisions to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds pagination and status-filter behavior but does not disclose ordering, error cases, or return handling. No contradiction with the annotations.

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

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

The description is a single front-loaded sentence containing the action, the resource, and the key modifiers. There is no redundant or filler content; 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 read-only list tool, the fully documented schema and read-only/idempotent annotations are enough for an agent to invoke it correctly. It does not specify allowed status values or the exact response shape, but the core invocation context is adequately covered.

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

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

Schema description coverage is 100%, and the schema already explains all four parameters including default limit, offset semantics, and workspace_id requirement. The description only restates 'status filter and pagination' at a high level, adding no extra 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 starts with a specific verb and resource, 'Lists campaigns', and adds the optional status filter and pagination, making the tool's purpose clear. It is distinct from create/update campaign tools and from list_campaign_plan_items by naming the campaign resource, though it does not explicitly contrast itself with sibling tools.

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

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

The description implies this is the tool to use when listing campaigns and indicates that status filtering and pagination are available. However, it does not explicitly state when to choose it over sibling tools like list_campaign_plan_items or list_posts, nor does it mention the workspace_id requirement beyond what the schema already provides.

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 non-destructive behavior, so the substantial security transparency is handled. The description adds useful context about returned account properties (capabilities), but it does not disclose output format, pagination, or the exact meaning of identity/health flags. It also introduces 'capability flags' without linking them to the input or output schema, which creates slight confusion. 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 short, with no verbose filler. The first sentence is informative and the second gives a practical use-reminder. However, the second sentence is slightly ambiguous and could mislead an agent into expecting a capability-flags input parameter, which is not present in the schema.

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

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

For a simple, read-only listing tool with only two well-documented parameters and a rich annotation block, the description is nearly sufficient. It outlines what data the tool exposes and gives a target-selection workflow hint. It is missing an explicit return-value shape or note on how 'capability flags' map to other tools, but for this complexity level, the description is adequately 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 fully explains both parameters (request_id as an echoed tracing field, workspace_id as conditionally required). With 100% schema coverage, the description does not need to explain them, but it also adds no method hint. The phrase 'capability flags' does not correspond to any schema parameter, so the description does not assist with parameter meaning.

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

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

The description clearly identifies the resource as connected accounts and conveys a listing operation, especially through the title 'List Connected Accounts'. It distinguishes itself from sibling list tools (e.g., list_posts, list_workspace_assets) by enumerating account capabilities: identity, health, and publish/inbox/comment/insight.

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 practical use hint ('Use capability flags to choose targets'), implying this tool is a starting point for selecting accounts. However, it does not explicitly state when to prefer this tool over sibling list tools, nor does it give any exclude guidance. The intended usage is therefore more implied than explicitly scoped.

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

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

In addition to the annotations (readOnly, idempotent, non-destructive), the description adds the 'visible' scope and a specific pagination contract: layering on next_offset until has_more is false. These are useful behavioral details beyond the annotations, even though sorting and return format are not described.

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

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

Two sentences carry all essential information: purpose first, then the pagination rule. There is no fluff, redundancy, or verbose preamble.

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?

Combined with the rich schema, the description gives enough context for an agent to list posts and paginate correctly. 'Visible' is not fully defined and the return shape is not explicit, but for a read-only list tool with no output schema, these are moderate gaps covered by the pagination note and 'posts' wording.

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

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

The schema covers all seven parameters with descriptions, including defaults and allowed values, so schema coverage is 100%. The tool description does not need to add parameter-level semantics; it also mentions next_offset/has_more, but those are response fields, not input 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 identifies the action ('lists') and the resource ('visible posts') and mentions filters and pagination. It is distinct from sibling list tools by focusing on posts, though it does not explicitly compare itself with invoke_get_post or other list tools.

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

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

The description provides pagination instructions but does not state when to use this tool versus alternatives like invoke_get_post or invoke_list_campaigns. There are no exclusions, alternative conditions, or explicit context selection cues beyond the generic phrase 'Lists visible posts'.

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

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

Annotations already cover readiness and safety: readOnlyHint, idempotentHint, and non-destructive false. The description adds 'available to the authenticated user', which gives useful scoping context, but it does not describe the response shape, pagination, or what happens when no workspaces are available.

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

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

The description is a single clear sentence with no filler or redundancy. It presents the core function in a directly usable way.

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

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

For a zero-parameter read-only list operation with annotations declaring safety, the description is nearly complete. It states a simple, realistic outcome, though it does not mention any output details, which are minor for this simple 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 tool takes no parameters, so there are no parameter semantics to explain. The empty schema is fully covered, and the description has no obligation to define nonexistent arguments.

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 ('Lists') and a specific resource ('workspaces'), and clarifies the scope to the authenticated user. It clearly reads as a list-operation and is distinct from sibling list tools by naming the workspace resource 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?

No guidance is provided about when to choose this tool over alternatives such as invoke_get_workspace_context or invoke_list_workspace_assets. The description states what the tool does but gives no comparison, exclusion, or situational advice.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds that results are paginated and filterable, which is beyond the annotations, but it omits the non-obvious dual pagination mode (offset vs scan_cursor) that materially changes how the tool is driven.

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 front-loaded sentence with zero filler. It is efficient, though perhaps too terse for a six-parameter tool with a non-trivial cursor mode.

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?

Six all-optional parameters, no output schema, and a scan_cursor paging path that only makes sense in combination with filters. The schema documents each parameter individually, but the description leaves out what is returned and how the two pagination strategies relate, which is the main place an agent can go wrong.

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 each parameter carries a description, so the schema does the heavy lifting. The description only restates the type and gallery filters and the existence of pagination, adding no semantics beyond the schema (e.g., it never mentions the multi-workspace requirement or the scan_cursor protocol).

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

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

States a specific verb and resource ('Lists workspace assets') plus the two capabilities that matter (pagination, type/gallery filters). It does not differentiate itself from sibling list tools such as invoke_list_posts or invoke_list_campaigns, so an agent must infer that this one is for the asset library specifically.

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 no when-to-use guidance, no prerequisites, and no alternatives. The only routing hint in the whole definition lives in the schema ('Optional ID from list_asset_galleries'), not the description, so nothing tells an agent to prefer this over other listing tools.

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

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

Annotations already provide readOnlyHint, idempotentHint, and non-destructive guarantees, so the description's extra behavioral context of returning 'valid or the required fix' adds clarity beyond the annotations. It communicates that this is a check-only operation with an actionable result. It does not mention rate limits or auth requirements, but for a read-only preflight tool with annotations covering safety, this is sufficient.

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

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

The description is two short sentences with zero filler. It front-loads the validation scope and immediately states the output outcome. Every sentence adds direct value.

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

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

For a simple, read-only, one-required-parameter tool, the description captures purpose, timing, output, and effect. The schema handles all parameter documentation, and annotations handle safety behavior, so nothing needed by an agent to invoke the tool 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 coverage is 100%, so every parameter already has a clear description. The tool description adds no new meaning for individual parameters beyond mapping the concept of 'platform/content type' to those optional fields. The baseline of 3 is appropriate because the schema handles parameter semantics 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 names a specific verb ('Checks'), the resource being validated ('a post's media'), and the criteria ('against its platform/content type'). It also distinguishes itself from sibling action tools by stating it is a preflight validation before schedule, publish, or retry rather than being one of those actions.

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

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

The description explicitly identifies when to use the tool: 'before schedule, publish, or retry'. This gives clear contextual guidance without naming a sibling alternative, which is acceptable because no other sibling appears to offer a preflight validation pass. It stops short of a 5 because it does not state exclusions or explicitly name alternative tools.

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

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

Goes well beyond the annotations: it discloses irreversibility, asynchronous behavior, that publish_status=PUBLISHING is not yet live, and how to confirm success (is_published=true). This is critical behavioral context for a destructive async operation, and it aligns with destructiveHint and readOnlyHint=false. No contradiction with annotations.

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

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

The description is compact and efficiently front-loaded: main behavior and irreversibility first, then conditional routing, then async confirmation. Every sentence earns its place and none repeat schema or annotation content mechanically.

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

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

For a destructive async mutation tool with no output schema, this description is unusually complete. It tells the agent when to call it, what state transitions matter, what to do in alternate states, and how to verify the publish actually completed. The only absence is a full return-shape spec, but the confirmation instruction compensates for the missing output schema.

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

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

Schema coverage is 100%, so the schema already documents post_id and override_approval. The description reinforces override_approval indirectly by mentioning the pending-approval bypass path, but it adds no new parameter-level meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('Publishes a public Post') plus a clear precondition ('only on explicit user request'). It also distinguishes itself from adjacent workflows by naming approve_post and retry_failed_publication as the correct paths for PENDING_APPROVAL and FAILED states, so an agent can tell them apart.

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

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

Gives explicit when-to-use guidance ('only on explicit user request'), a firm caution ('cannot be undone'), and explicit alternatives for two non-ready states: PENDING_APPROVAL should route to approve_post or override_approval, and FAILED should route to retry_failed_publication. This removes ambiguity about when not to call 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 signal readOnlyHint=false, destructiveHint=true, and idempotentHint=true. The description adds useful nuance by explicitly stating the lifecycle transition and emphasizing that content is not deleted, which helps reconcile the destructiveHint. It does not fully explore irreversibility or side effects, but it adds value 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?

A single sentence conveys the core action, the applicable state, the resulting state, and the key non-destructive guarantee. The information is front-loaded and there is 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 two-parameter state-transition tool with annotations covering read-only and idempotency behavior, the description is sufficient. It answers what, when, and what happens, while the input schema covers the parameter details. No critical call-affecting information 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%: post_id and reason are already well documented in the input schema. The description's 'PENDING_APPROVAL post' provides context about the affected resource, but it does not add new parameter-level semantics beyond what the schema already states.

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

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

States a specific action (rejects), a specific resource state (PENDING_APPROVAL post), and a clear outcome (moves lifecycle to CANCELLED). The clarification 'without deleting content' further distinguishes it from destructive actions and nearby workflow 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 clearly identifies the intended context: only PENDING_APPROVAL posts should be rejected, and the result is a lifecycle move to CANCELLED. It does not explicitly name alternatives or exclusions, but the precondition is concrete enough for an agent to decide when this tool applies.

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

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

Annotations already mark this as destructive and idempotent. The description adds the key behavioral constraint that callers must supply the same IDs, meaning omitted IDs are not allowed or would break the operation. This is useful beyond the raw annotations and there is no contradiction.

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 captures the action and the critical constraint. Every word earns its place, and there is no redundant filler.

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

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

For a two-parameter tool with full schema coverage and safety annotations, the description is complete. The required post_id and the list of all current asset IDs are both covered, and the agent can invoke the tool correctly without further context.

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

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

The schema already documents both parameters fully, including that asset_ids must be 'all currently attached Asset IDs in the desired order.' The description mostly restates the asset_ids semantics, adding little 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 ('reorders') and a clear resource ('existing post assets'), and distinguishes itself from the sibling attach/detach tools by emphasizing that the ID list contains the same IDs in a new order, not a modified set.

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 you want to reorder already attached assets. It implies the contrast with attach/detach tools, though it does not explicitly name them or state 'when not to use'.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, openWorldHint=true and readOnlyHint=false, so the safety/write profile is covered. The description adds one useful precondition (only SCHEDULED posts, only the future publish time changes), but omits error behavior for non-scheduled posts and does not clarify whether the prior time is replaced or retained.

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 with zero filler; the scope qualifier 'SCHEDULED' appears before the action. It is efficient, though arguably too terse for a mutation tool, which is penalized under other dimensions rather than here.

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

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

For a mutation with full annotation coverage and a fully documented three-param schema, the description covers the core scope but leaves gaps: no error/precondition handling for non-scheduled posts, no note on whether rescheduling supersedes the previous time, and no mention of approval or publishing 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?

Schema description coverage is 100% (three params fully documented, including the ISO 8601 future-datetime constraint and IANA timezone), so the baseline is 3. The description only reinforces 'future' via 'future publish time' and adds no format or validation detail beyond the schema.

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

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

States a specific verb ('Changes') and resource ('publish time') scoped to a 'SCHEDULED post,' which reasonably separates it from siblings like invoke_schedule_post and invoke_cancel_scheduled_post. It does not name any sibling explicitly, so differentiation is inferred rather than stated.

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

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

No when-to-use, when-not-to-use, or alternative guidance is given. The capitalized 'SCHEDULED' implies a precondition (post must already be scheduled) but the description never tells the agent what to do if the post is a draft, already published, or being approved instead.

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

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

Annotations already provide idempotentHint and destructiveHint, and the description adds meaningful process context beyond them: that media validation occurs first, the post is re-queued, and publication is automatic via the scheduler. This helps the agent anticipate the asynchronous flow. 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 with zero waste. The key discriminator (FAILED) leads, and the internal pipeline is conveyed compactly.

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 retry tool with no output schema, the description explains the full lifecycle after invocation. It covers the validation step, the re-queue, and the automatic scheduler publish, which is sufficient for a caller to know what will happen.

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 there is only one parameter (post_id), documented as 'Socializioz post ID.' The description adds nothing beyond the schema, so the baseline of 3 is appropriate since the schema already carries the full burden.

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 (retries) and resource (a FAILED post), with the retry pipeline spelled out (media validation → re-queue → scheduler auto-publish). The FAILED qualifier distinguishes it from sibling publishing tools like invoke_publish_now and invoke_schedule_post, though it doesn't name 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 FAILED condition implies when to use it (only for failed posts), but there are no explicit exclusions or named alternatives. An agent must infer the appropriate selection among publish_now, schedule_post, and reschedule_post rather than being told.

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, idempotentHint=true, openWorldHint=true. The description adds the genuine extra context of an approval gate and the mechanism to bypass it, which is not encoded in the annotations. It stops short of saying what the destructive/open-world effect actually is (e.g., external publication).

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, with the core action stated first and the conditional approval rule immediately after. Nothing to trim.

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

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

For a 4-param mutation with no output schema and full annotation coverage, the description supplies the one thing an agent would otherwise miss: the approval gate and its bypass. Failure behavior and timezone/UTC interactions remain unaddressed, but those are minor here.

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

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

Schema coverage is 100%, so post_id, schedule_at, timezone and override_approval are all already documented. The description's note on override_approval largely restates the schema's own wording, adding no syntax or format detail beyond it — baseline 3.

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

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

Clear specific verb+resource: 'Schedules a post.' The description also names the approval prerequisite, which helps separate it from related lifecycle siblings, though it never distinguishes itself from invoke_reschedule_post or invoke_publish_now, which sit adjacent in the tool 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?

Gives a concrete conditional rule: pending review requires approve_post, or override_approval=true only when the user explicitly asks to bypass review. That is real when-to-use guidance, but there is no guidance on choosing this tool over reschedule_post or publish_now.

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

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

The description goes beyond the annotations by specifying the exact behavior: moving from DRAFT to PENDING_APPROVAL and creating an approval request. Annotations already cover idempotency and destructiveness; the description supplements them usefully with the target state. It does not elaborate on side effects of the destructive hint, but the core behavior is transparent.

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

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

The description is a single, compact sentence that front-loads the purpose and includes the most decision-relevant information: the state change and the creation of an approval request. No word is wasted.

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

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

For a two-parameter tool with a clear state transition, the description is largely complete. The only minor gap is that it doesn't describe what outcomes the caller can expect beyond the transition and doesn't mention any preconditions for the draft, though these are partly inferable from the schema and annotations.

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

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

The input schema already documents all parameters with 100% coverage, describing post_id as 'Socializioz post ID' and request_id as an optional correlation id. The description does not add further parameter semantics, which is acceptable given the schema's completeness.

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 ('Moves') plus a precise resource and state transition: 'Moves a DRAFT to PENDING_APPROVAL and creates a human approval request.' This clearly separates it from siblings like invoke_approve_post, invoke_reject_post, or invoke_publish_now.

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

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

Usage is implied through the state transition: the tool is for taking a draft and sending it through an approval request. However, the description does not explicitly state when to use this tool versus alternatives such as invoke_approve_post or invoke_publish_now, and doesn't provide exclusions or requirements.

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

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

Beyond the annotations, the description adds the important behavior that only the supplied fields are changed. This clarifies that unspecified fields are left as-is and that the call is not a full replacement or upsert. Annotations already indicate this is a non-read, destructive operation, and the description does not contradict 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?

One sentence with no filler. It front-loads the operation, the object, and the partial-update semantics. Every word adds value.

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

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

For a small, non-nested update tool with fully documented parameters and annotations indicating destructive behavior and idempotency, the description covers the essential operational context. It could mention the return value, but in the absence of an output schema this is a minor gap.

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

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

The input schema documents all five parameters with 100% coverage, so the schema already explains the fields. The description adds meaning by indicating that whatever fields are supplied apply as updates and that others are not affected, which clarifies the role of optional parameters and the required id.

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 ('Updates') and names the resource ('campaign fields') and clearly scopes it to a partial update ('only the supplied campaign fields'). This differentiates it from create-campaign and campaign-plan-item tools, though it does not explicitly name alternatives.

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

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

The description provides no when-to-use guidance and does not mention alternatives or exclusions. An agent has to infer from the sibling names which update tool to choose, and for an operation with multiple 'update_*' siblings this is a notable gap.

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

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

The description adds a meaningful behavioral detail beyond what annotations provide: it explicitly states that only the supplied fields are updated, implying omitted fields remain unchanged. This valuable PATCH-like behavior is not fully expressed by the readOnly hint or destructive hint and helps reduce risk during 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 a single front-loaded sentence with no filler: 'Updates only the supplied plan-item fields.' The phrasing is compact and immediately readable while still conveying the core operation and its partial-update scope.

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

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

This is a simple update operation with a 4-field schema, 100% schema coverage, and annotations for safety and idempotency. The only notable gap is missing guidance about how this tool relates to sibling operations like update_campaign or create_campaign_plan_item, but the description plus schema gives enough information to plausibly select and call it in most contexts.

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?

Since the schema covers 100% of parameters, the description's role is smaller. However, 'only the supplied fields' clarifies that optional parameters are truly optional and that omitting them leaves their existing value unchanged, highlighting a semantic nuance that would otherwise be guessed.

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 'Updates' and resource 'campaign plan', then adds an important scoping qualifier: 'only the supplied fields.' This conveys partial update semantics and differentiates the tool from create/list plan-item operations, even though it does not explicitly name the alternative 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?

There is no guidance on when to use this tool versus alternatives such as invoke_create_campaign_plan_item or invoke_update_campaign. The reader must infer the appropriate selection solely from the tool name and sibling list, providing no confidence about when this is the right choice.

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

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

The description adds a meaningful behavioral restriction beyond what the annotations alone provide: only drafts are editable, and attempts on other states will fail. The destructiveHint and idempotentHint annotations already convey the mutation profile, and the schema's 'Replacement' wording covers replacing fields. No contradiction exists between the description and annotations.

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

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

Two short sentences say everything necessary: what the tool does and which states are excluded. There is no filler, redundancy, or irrelevant context, and the most important state restriction is placed prominently.

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?

Together with the complete schema descriptions and rich annotations, the description is enough for correct invocation: it identifies the target state, the operation, and the impossibility of other states. The only minor gap is that it does not mention what the response or return value is, but with no output schema this is not a required part of successful invocation.

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

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

Schema description coverage is 100%, so the input schema already documents all eight parameters, their purposes, and their roles. The description itself does not add parameter-level detail, which is acceptable because the schema carries that burden. Baseline 3 is appropriate here.

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: 'Updates a DRAFT post,' which immediately distinguishes this tool from scheduling, approving, or publishing tools. The explicit constraint 'Other states are not editable here' further clarifies the exact scope of the operation, leaving no ambiguity about what the tool does.

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

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

The description gives a clear when-to-use condition: only for draft posts. It also gives an explicit when-not-to-use boundary: other states are not editable here. While it does not name a specific alternative tool, the state restriction is unambiguous and enough for an agent to decide whether to invoke this tool.

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