SocialBu MCP

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

With no annotations, the description carries the behavioral burden and does add useful details: media is uploaded automatically, HTTP(S) URLs up to 500MB or base64 data URLs up to 75MB are accepted, and options are JSON-encoded. However, it does not disclose queue_id validation, whether the operation is reversible, or any error/response behavior, leaving transparency partial.

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

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

The description is two focused sentences with no filler. It front-loads the purpose, then packs the media constraints and options workflow into compact, easily parseable clauses.

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

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

For a mutation tool with no output schema and no annotations, this is near-adequate: it covers purpose, media handling, and options. But it leaves the agent to infer what content accepts and how to obtain a valid queue_id, so it is not fully self-sufficient for correct invocation.

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

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

Schema coverage is only 25%, so the description must compensate. It adds strong semantics for media_urls (URL forms, size limits, automatic upload) and options (JSON-encoded object from get_post_options). But content is never described, and queue_id is only implicitly tied to the 'custom publishing queue,' so compensation is incomplete.

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: 'Add content to a custom publishing queue.' The phrase 'custom publishing queue' clearly distinguishes this from direct-publish siblings like create_post or publish_post_now, so an agent can recognize its role immediately.

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

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

The description conveys a queue-based workflow and tells the agent to use get_post_options for valid options, which gives clear usage context. It does not explicitly contrast this tool with direct publishing alternatives, so it falls short of full when-to-use vs. when-not-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does add a permission requirement and an implied state precondition (the post must be awaiting approval). However, it does not mention whether the approval is irreversible, what side effects occur, or what the response format looks like—important gaps for an approval action.

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

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

The description is two sentences with no wasted words—first sentence gives the core action and state, second gives the permission requirement. It is front-loaded with the main purpose and stays efficient.

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

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

For a simple one-parameter approval tool with no output schema, the description gives the essential context: what action is performed, when it applies ('awaiting team approval'), and what prerequisite must hold (approval permission). It doesn't specify return details, but for a straightforward state update, this is sufficient.

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

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

The schema has 0% description coverage for the single parameter 'post_id', and the tool description does not explicitly define the parameter either. The meaning is strongly implied by the tool name and the phrasing 'a post,' but the description adds no direct semantic detail about the post_id field, so it only partially compensates for the schema gap.

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

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

The description clearly states the action with a specific verb ('approve') and a specific resource ('a post'), and it includes the context of being 'awaiting team approval.' This is immediately distinguishable from sibling tools like reject_post (opposite action) and publish_post_now (which triggers publication rather than approval).

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

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

The description provides a clear scenario of when to use the tool: when a post is awaiting approval. It also mentions a prerequisite ('Requires approval permission in the team'). However, it doesn't explicitly mention exclusions or alternative tools, so it stops short of being fully prescriptive.

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

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

No annotations are provided, so the description carries the full disclosure burden. It states the action and scope but does not mention side effects, permanence or reversibility of archiving, auth requirements, or how already-archived items are treated. This is a meaningful gap for a mutation tool.

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

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

The description is short and front-loads the main action. The 'Params:' sentence is somewhat redundant with the schema, but it does not add significant clutter. Overall it is appropriately sized for a one-parameter tool.

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

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

For a simple one-parameter tool, the description states the core operation and the required argument, which is enough for a basic invocation. However, it lacks behavioral context such as reversibility, return behavior, and guidance relative to sibling tools, so it is not fully complete.

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

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

Schema description coverage is 0%, so the description needs to compensate. It only repeats that stream_id is a required integer and connects it loosely to 'a Listen stream.' It does not explain what the stream_id represents, where to find it, or any constraints beyond the schema.

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

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

The description uses a specific verb ('Archive') and a clear object ('every active item in a Listen stream'), which communicates the scope and distinguishes it from the singular archive_listen_item tool. However, it does not explicitly differentiate itself from the sibling bulk_archive_listen_items, leaving some ambiguity.

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

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

The intended usage is implied: use this when you want to archive all active items in a stream. However, there is no explicit guidance about when to prefer this over archive_listen_item or bulk_archive_listen_items, and 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?

No annotations are provided, so the description bears the full burden of behavioral disclosure. It states that the tool 'archive[s]' an item, implying a state change, but it does not explain whether archiving is reversible, what happens to the item afterward (e.g., whether it disappears from the stream), or any permission requirements. The description is too sparse to convey the behavioral profile of a mutation operation.

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

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

The description is a single, compact sentence that front-loads the action and resource, then lists the parameters. There is no redundancy or filler; every word serves a purpose. It is appropriately sized for a simple two-parameter tool.

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

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

Given the tool's simplicity and lack of output schema or annotations, the description is still incomplete. It omits crucial context such as the meaning of archiving, the effect on the item's visibility, and how to distinguish this from deletion (delete_listen_item) or bulk operations. An agent selecting this tool would need more information to decide if it is the right choice and to understand the consequences of invoking it.

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

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

The schema already declares stream_id and item_id as required integers, and the description simply restates 'stream_id required integer; item_id required integer,' adding no new meaning beyond the schema. It does not explain what each parameter represents, how they relate (e.g., item belongs to stream), or any format constraints. With schema coverage at 0%, the description fails to compensate for the lack of parameter documentation.

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

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

The description clearly states the action ('Archive') and the resource ('one item in a Listen stream'), using the word 'one' to distinguish from bulk operations like archive_all_listen_items or bulk_archive_listen_items. The verb is specific and the resource is unambiguous, so an agent can determine the tool's function without opening the schema.

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

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

The phrase 'one item' implies this is for single-item archiving, but the description does not explicitly mention when to use this tool over alternatives like bulk_archive_listen_items or archive_all_listen_items. There is no explicit when/when-not guidance or mention of sibling tools, so the usage context is only implicit and relies on the agent inferring from the singular 'one'.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only says 'Archive multiple active items,' but does not state whether this is irreversible, what happens to already archived items, if permissions are required, or if it returns a summary. The action 'archive' is clear, but side effects are not disclosed.

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

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

The description is concise (two sentences) and front-loaded with the key purpose. It wastes no words, though it could be slightly more structured by separating purpose from parameter details. The parameter info is useful, and no redundancy.

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

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

For a mutation tool with no annotations and no output schema, the description covers the essentials (what and on what), but lacks behavioral context like idempotency, failure conditions, or whether items must be active. It is adequate for a simple bulk operation but leaves some risk.

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

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

Schema coverage is 0%, so the description must explain both parameters. It does so: 'stream_id required integer' and 'item_ids required array of integer item IDs,' which adds meaning beyond the bare schema types. It clearly indicates which stream and which items are affected, though it could mention that item_ids must belong to the specified stream.

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

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

The description clearly states the tool's action (archive multiple) on a specific resource (active items in a Listen stream), with parameters provided. It distinguishes from siblings like archive_listen_item (singular) and archive_all_listen_items (all), though it does not explicitly name them.

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

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

No guidance on when to use this tool versus alternatives. While the description implies it is for multiple items, it does not mention conditions like 'use bulk_delete_listen_items for deletion' or 'use archive_all_listen_items for all.' It assumes the agent understands the need for bulk archiving.

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

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

With no annotations, the description must disclose behavioral traits. It states the destructive delete action and a permission requirement, but does not mention whether deletion is permanent, reversible, or what happens to associated data. No information on return values, errors, or side effects is provided.

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 efficient, but the second sentence listing parameters is redundant with the schema, providing no additional value. The core purpose is front-loaded, but the redundancy slightly reduces overall efficiency.

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 bulk operation with two simple params and no output schema, the description is incomplete. It lacks expected return values, error handling, and postconditions. An agent would not know what to expect after calling the tool.

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

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

Schema description coverage is 0% because the description merely restates parameter types and requiredness already present in the schema. It adds no semantic meaning, such as what stream_id refers to, the meaning of item_ids, or any constraints beyond basic types.

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

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

The description clearly states the action ('Delete') and the target ('multiple items from a Listen stream'), distinguishing it from single-item deletion (delete_listen_item) and archiving (archive_listen_items). The 'multiple items' phrasing directly conveys the bulk scope.

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

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

The description provides a prerequisite (Manage Social Listening permission) but no guidance on when to choose this tool over alternatives like bulk_archive_listen_items or delete_listen_item. It does not mention use cases, exclusions, or trade-offs.

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

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

With no annotations, the description fully discloses behavior: it returns a signed URL, requires a PUT with the same Content-Type, expires the URL in 30 minutes, and the temporary URL is valid for 24 hours. It also notes the file must be 'agent-held', implying the agent must have the file content. No contradictions.

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

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

The description is two sentences but packs a full workflow: input requirements, the signed URL action, timing, and the post-creation integration. Every clause carries necessary information with no filler. The critical steps are front-loaded.

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

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

For a 2-parameter tool with no output schema and no annotations, the description covers all needed information: what to provide, what the response is, how to act on it, and temporal constraints. An agent has everything needed to call it correctly. The only minor omission (e.g., error behavior) is negligible given the tool's simplicity.

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

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

The schema has zero description coverage, so the description is the only source of parameter meaning. It explicitly maps 'name' to 'original filename' and 'mime_type' to 'MIME type', removing ambiguity. This adds significant semantic value beyond the bare schema definition.

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

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

The description clearly states the action ('Create a direct media upload'), the resource ('for an agent-held file'), and the purpose without ambiguity. It names the tool's specific function and distinguishes it from siblings, none of which are media-upload related, so no differentiation is needed but it stands 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?

Provides explicit step-by-step usage: provide filename and MIME type, PUT raw bytes to signed_url with same Content-Type within 30 minutes, then use the temporary url in media_urls when creating a post. This is an exact 'how to use' guide with timing constraints, leaving no guesswork.

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

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

With no annotations provided, the description carries the full burden, and it discloses substantial behavior: scheduled_at must be UTC (Y-m-d H:i:s), media uploads are automatic from HTTP(S) or base64 data URLs with explicit size caps (500MB HTTP, 75MB/56MB base64), awaiting_approval creates a post pending team approval, and post_type defaults to scheduled. This is rich behavioral context, though it omits auth requirements, reversibility, and response format.

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 dense paragraph with the core purpose front-loaded and every sentence carrying operational value. It is not padded, but a bit of structure (bullets or clause separation for the distinct concerns: scheduling, media, options, post_type) would improve scannability for an agent.

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 6-parameter creation tool with no annotations and no output schema, the description covers the critical decision points: scheduling format, media constraints, post-type semantics, and options sourcing. It omits the response/return shape and failure behavior, which is a gap, but the operational essentials an agent needs to invoke it correctly are present.

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 only 17% (solely the options parameter), so the description must compensate, and it does: it specifies scheduled_at's exact format, media_urls' accepted types and size limits, post_type's three valid values with default, and that options must come from get_post_options as a JSON-encoded object. This adds real meaning beyond the bare 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 opens with a specific verb and resource: 'Create or schedule a social media post to a single account.' This clearly distinguishes it from siblings like update_post (modification), publish_post_now (immediate publishing), and add_post_to_queue (queue addition). The single-account scope is explicit, which separates it from bulk or multi-account tools.

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

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

The description implies when to use the tool through its post_type options (scheduled, draft, awaiting_approval) and mentions get_post_options as a dependency, but it never explicitly states when NOT to use this tool versus alternatives like publish_post_now or update_post. The routing guidance is implied rather than stated, leaving the agent to infer boundaries.

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

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

With no annotations, the description must disclose behavioral traits on its own. 'Remove' implies a destructive action, but the description does not state that the removal is permanent, whether it affects posts or metrics, or if any confirmation is needed. This is a significant gap for a deletion operation.

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

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

The description is a single, concise sentence that directly states the action and resource. There is no fluff or redundant information, making it efficiently front-loaded.

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

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

For a tool with one parameter, no annotations, and no output schema, the description is incomplete. It omits critical details like permanence, side effects, error conditions, or any confirmation steps. An agent has to guess at the behavior, making the definition insufficiently complete.

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

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

Schema description coverage is 0%, and the description does not mention the account_id parameter at all. The agent must infer that the ID is required, and there is no clarification about what constitutes a valid ID or how to obtain it. The description adds no value beyond the schema's bare type.

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

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

The description uses a clear verb ('Remove') and a specific resource ('connected social media account'). It distinguishes from other delete tools that target different resources (e.g., delete_post, delete_listen_item). However, it does not explicitly contrast with update_account or reconnect_account, so it's not 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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, such as whether the account must be connected or if there are conditions that would make removal inappropriate. The agent receives no directional help.

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

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

With zero annotations, the description carries the full burden of behavioral disclosure. It does add a permission prerequisite ("Requires Manage Social Listening permission"), but it does not expose whether the deletion is irreversible, whether it cascades to related items, or what response or side effects to expect. For a destructive tool this leaves significant ambiguity.

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 purpose. The permission note earns its place, and the param list is obvious. The list is redundant with the schema, but the description is still appropriately sized and not wordy.

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 action with no output schema and no annotations, the description does not go far enough. It leaves the agent to guess about call semantics (e.g., whether the item is permanently removed, if other items re-index), risks of failure, and postconditions. The added permission detail justifies a partial score, but important gaps remain.

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 0%, so the description must compensate. However, it merely restates the schema's already-declared integer types and required flags ("stream_id required integer; item_id required integer") and adds zero semantic meaning about what these IDs identify or where to find them. This provides no value beyond the input 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?

"Delete one saved item from a Listen stream" states a clear verb, resource, and singular scope. The word "one" naturally distinguishes it from bulk_delete_listen_items and archive_listen_item, so an agent can set it apart from siblings.

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

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

The description gives no when-to-use or when-not-to-use guidance. It does not point to alternatives like archive_listen_item or bulk_delete_listen_items, nor does it mention any conditions that should lead the agent to choose another tool. The only context added is a permission requirement, which is not a usage guideline.

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

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

With no annotations, the description carries the full burden of behavior disclosure. The verb 'Delete' signals a destructive operation, but nothing is said about irreversibility, permissions, side effects on related objects, or behavior when the post doesn't exist.

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 redundant content. The action word and target are front-loaded, and there is no ambiguity about the purpose once the schema is consulted.

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

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

The tool is simple with one required parameter, so the definition is minimally viable. However, as a destructive operation with no annotations and no output schema, it should probably state whether deletion is permanent, what the response is, and whether related data is affected.

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 0%, so the description must compensate. 'By ID' clarifies that post_id is the identifier of the post to delete, but the parameter name 'post_id' and integer type already convey most of that meaning, adding little new semantic value.

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

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

Description uses a specific verb plus resource: 'Delete a single post by ID.' It distinguishes itself from sibling tools like bulk_delete_listen_items and delete_listen_item through the singular 'post' target and 'single' scope, so an agent can select it correctly without opening schemas.

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

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

Usage context is only implied by the phrase 'Delete a single post by ID.' No explicit when-to-use, when-not-to-use, or alternative routing is provided, and the description does not mention that bulk deletions would use a different tool.

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

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

The description states the result is an OAuth URL, which is useful and honest. With no annotations, however, it does not disclose OAuth lifecycle details, such as whether the URL is one-time, what scopes are involved, or whether account creation only happens after the user authorizes.

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 crisp sentences with the main point first and a compact list of supported values second. There is no filler and the structure makes the core behavior immediately clear.

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

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

This is a one-parameter tool with no output schema and no annotations, and the description provides the necessary input semantics and return outcome. Additional OAuth flow detail would be nice, but the agent has enough to correctly invoke the tool and understand the result.

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

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

The schema provides no description for the required account_type, and schema coverage is 0%, so the description's supported-types list is the only documentation for the parameter. It adds real value, though it does not explain abbreviations like 'gmb' or confirm expected casing.

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

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

The description uses a specific verb and resource: 'Get the OAuth URL to connect a new social media account.' It also names the supported account types, which clearly distinguishes this from siblings like list_accounts and reconnect_account.

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

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

The 'new social media account' phrasing gives clear context for when this tool is appropriate, and the supported-types list tells the agent what inputs are valid. It does not explicitly mention the alternative for existing accounts, so it stops short of full guidance.

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

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

With no annotations, the description must disclose behavioral traits. It implies a read-only operation via 'Get' but doesn't state safety, permissions, or side effects. It also doesn't explain default behavior when parameters are omitted or the response format, so the agent is left without important context.

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

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

The description is a single concise sentence with no filler, front-loading the core purpose. However, its brevity contributes to the lack of crucial details, though for conciseness alone it is efficient.

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

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

Given four optional parameters, no output schema, no annotations, and many sibling tools, the description is severely incomplete. It fails to explain return value structure, parameter semantics, or when to choose this over related metrics tools, leaving the agent with significant 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 0%, so the description must compensate for parameter meaning. It mentions example metrics but never connects them to the actual parameters (metrics, date_from, date_to, account_ids). It doesn't explain date formats, default behavior, or valid values, making it impossible to populate parameters correctly from the description alone.

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

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

The description clearly states it retrieves account-level metrics (followers, impressions, reach) for connected social accounts, using the specific verb 'Get' and a specific resource. It distinguishes from post-level tools by the 'account-level' qualifier, though it doesn't 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?

No guidance is provided on when to use this tool versus siblings like get_post_metrics or get_stats_overview. There are no conditions, exclusions, or prerequisites mentioned, leaving the agent to infer selection criteria from the name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Get details' implying a read-only operation, but does not disclose any side effects, error handling, authentication requirements, rate limits, or what happens if the ID is invalid. This is a significant gap for a tool with zero annotation coverage.

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

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

The description is a single concise sentence that is front-loaded with the action and resource. It avoids unnecessary words and is easy to parse. However, it is so terse that it sacrifices essential context, so while structure is clean, it is not as informative as it could be for a tool with no other documentation.

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 get-by-ID tool with one parameter, no output schema, and no annotations, the description is incomplete. It does not describe the return format, the breadth of 'details', error cases, or any prerequisites. An agent cannot fully predict the tool's behavior or response, making it inadequate for reliable invocation.

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

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

The schema has one parameter, automation_id, with no description, and schema description coverage is 0%. The description says 'by ID' but does not explain what the ID represents, how to obtain it, or any constraints (e.g., integer format, required). It adds minimal value beyond the schema's bare type and required flag.

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

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

The description clearly states the action (Get details) and the resource (a specific automation by ID). It distinguishes from sibling tools like list_automations (which lists all) and get_automation_log (which gets logs), so an agent can infer the basic purpose. However, it does not explicitly specify what 'details' includes or how it differs from other get tools, so it stops short of 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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of using list_automations to find IDs, or get_automation_log for logs, or when a full detail fetch is appropriate. An agent must infer usage from the name and siblings, which is insufficient.

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?

There are no annotations, so the description carries the full burden. It does not disclose read-only behavior (though 'get' implies it), authentication requirements, pagination behavior, or what 'recent' means. The term 'recent' is vague and offers no concrete time frame or ordering details.

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

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

The description is two concise sentences with no redundant words. The core action is front-loaded, and the optional filter is stated clearly. 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?

With no output schema and no behavioral details, the description is incomplete. An agent does not know what the logs contain, how many are returned (though limit default hints), or how they are ordered. It leaves critical return-format information entirely unspecified.

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

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

The schema description coverage is 0%, so the description must explain the parameters. It mentions 'Optionally filter by automation ID,' which adds meaning for automation_id, but it completely omits the limit parameter and its purpose. The defaults in the schema are not enough context for an agent to use the limit meaningfully.

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

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

The description states a clear verb and resource: 'Get recent automation execution logs.' It distinguishes implicitly from siblings like get_automation and list_automations, as no other tool targets logs. However, it does not explicitly name any alternative or scope, so it misses the top score.

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 on when to use this tool versus other automation-related tools (e.g., get_automation for configuration, list_automations for definitions). The description only states what it does, with no exclusions or conditional contexts.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether this is a read-only operation, whether results are paginated, how filters combine, what the response shape is, or whether any side effects occur. The description adds only a list of filter dimensions, not behavioral context.

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

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

The description is a single sentence with no filler, and the key action and resource are front-loaded. It is appropriately concise, though it could earn a 5 by adding a brief usage condition or alternative reference without bloating.

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 six parameters, no annotations, no output schema, and 0% schema description coverage, the description is too thin. An agent cannot determine pagination behavior, filter combination rules, or what a 'curated content item' is in this context. The description is adequate only for a rough first-pass selection, not for reliable 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 0%, so the description must compensate for six undocumented parameters. It names four filter dimensions (feed ID, search, source scope, time range) but does not explain the 'limit' parameter or the 'team_id' parameter, and it does not clarify value formats or filter combination semantics. This is a partial compensation at best.

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

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

The description states a specific verb ('Get') and resource ('curated content items'), and lists the available filter dimensions (feed ID, search, source scope, time range). It is clear enough to distinguish from siblings like list_listen_items or get_listen_item, though it doesn't explicitly name a sibling alternative.

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

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

The description implies usage by listing filter options, but it does not explicitly state when to use this tool versus alternatives like list_listen_items or get_listen_stream. There is no exclusion guidance or mention of prerequisites, so an agent must infer the appropriate context from the tool name and sibling list.

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

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

No annotations are provided, so the description carries the full burden. It states the tool is a read operation ('Get') but does not explicitly declare safety or side-effect profile, nor does it discuss authentication requirements, error behavior, or response format. The note about scheduling timestamps is tangential and could confuse agents about the tool's scope. Minimal but acceptable for a simple getter.

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

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

The description is brief (two sentences), but the second sentence about scheduling timestamps and UTC format is irrelevant to the tool's purpose and appears to be a copy-paste error. This extraneous information reduces clarity and adds noise, so it is not optimally concise.

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

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

For a parameterless read-only tool without an output schema, the description covers the essential information: what it returns (name, email, timezone, subscription plan) and a usage tip. The only weakness is the misplaced UTC note, which slightly detracts but does not create a major gap. Overall, an agent can invoke it correctly.

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

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

The tool has zero parameters, so the schema coverage is 100% by definition. The baseline for 0 parameters is 4, and the description adds no parameter-specific information (none needed). It appropriately includes the expected return fields, which is sufficient.

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

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

The description clearly states the action (get) and the resource (currently authenticated user) and enumerates specific fields: name, email, timezone, and active subscription plan. This is a precise, unambiguous purpose that distinguishes it from sibling tools like get_account_metrics or list_accounts.

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

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

The description implicitly defines when to use the tool (when you need the current user's identity and profile details) and even gives a practical tip on converting local time to UTC using the timezone field. It does not explicitly exclude alternatives or mention when not to use it, but given that no sibling tool serves the same purpose, the guidance is adequate.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only restates the high-level action and output content; it doesn't reveal return shape, aggregation, timezone/date handling, or account scoping behavior.

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

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

Single sentence with high signal-to-noise, front-loaded with the action and key context. No wasted words.

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

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

For a tool with no annotations and no output schema, this is too sparse. An agent is left without return-value structure, parameter semantics, or selection criteria relative to sibling tools.

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

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

With 0% schema description coverage, the description should compensate by explaining date_from, date_to, and account_ids. It establishes a date-range concept but doesn't specify formats, defaults, or how account_ids affects results.

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

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

States the verb 'Get', the resource 'engagement trend', and lists metric types and a date range. It clearly describes the core action but doesn't distinguish itself from sibling metrics tools like get_post_metrics or get_stats_overview.

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?

Does not specify when to prefer this tool over sibling metrics/trend tools, nor any exclusions or prerequisites. The date-range mention only implies the use case rather than providing explicit guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool 'gets' an item and does not describe return format, error behavior, authentication needs, or what distinguishes a saved item from a deleted or archived one.

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

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

The description is brief and front-loaded, with no filler or redundancy. Every sentence carries some information, though the conciseness comes at the cost of missing behavioral and usage context.

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

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

This is a simple two-parameter getter with a fairly self-evident return value, so the minimal description is not severely inadequate. However, with no output schema and no annotations, an agent still lacks details on response shape, potential null results, or error cases.

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

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

Schema description coverage is 0%, and the description merely restates the parameter names, types, and requiredness already present in the schema. It adds minimal semantic context like 'from a Listen stream' and 'saved item', but not enough to truly compensate for the schema's lack of descriptions.

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

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

The description names a specific verb ('Get') and a specific resource ('one saved item from a Listen stream'), making the tool's purpose clear. The singular 'one' helps distinguish it from list-style siblings, though it does not explicitly differentiate from 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?

There is no guidance on when to use this tool versus list_listen_items, get_listen_stream, or the archive/delete siblings. An agent is left to infer usage from the tool name and sibling set.

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

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

With no annotations, the description carries the behavioral disclosure burden. It makes clear this is a read operation and enumerates the returned data categories (query configuration, counts, RSS/embed URLs, quota state), setting accurate expectations. It does not cover auth or error behavior, but for a simple getter this is acceptable.

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

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

Two sentences with no filler: the core action is front-loaded, the returned content is summarized compactly, and the parameter constraint is stated in one phrase. Every sentence earns its place.

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

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

For a one-parameter retrieval tool with no output schema, the description covers the essential information needed to invoke it correctly: what it gets, how it selects it, and what the response covers. Minor omissions like not-found handling do not materially impair usability.

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

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

Although the schema only declares stream_id as a required integer, the description adds meaning by stating the tool retrieves the stream 'by ID' and that stream_id is required. For a single self-evident parameter, this is sufficient compensation for the 0% schema description coverage.

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

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

The description uses a specific verb ('Get'), resource ('Listen stream'), and selection scope ('by ID'), and lists what is included. This clearly distinguishes it from plural list tools like list_listen_streams and from the different-resource get_listen_item.

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

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

The description clearly implies the use case: fetch a single Listen stream when its ID is known. It does not explicitly name alternatives or exclusions, but the singular-by-ID framing provides enough context to route an agent away from the list variants.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention whether this is a read-only operation, whether date ranges are required or optional, how metrics are aggregated, what happens with invalid account_ids, or any pagination/response details. The description adds minimal behavioral context beyond the name and schema.

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

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

The description is a single concise sentence that front-loads the core purpose and includes the key metric types. It is efficient and easy to parse, though it could add a bit more context without becoming bloated.

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

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

Given the tool has 4 parameters, no output schema, no annotations, and 0% schema description coverage, the description is too thin. An agent would not know how to format dates, whether account_ids is required for filtering, what the response shape is, or how this differs from sibling metric tools. The description is adequate only for a very basic understanding.

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 0%, so the description must compensate for the four parameters. It mentions metrics and grouping by date, which loosely maps to the 'metrics' and date parameters, but it does not explain the format of date_from/date_to, the meaning of account_ids, or how the metrics parameter should be structured. The description adds some meaning but leaves most parameter semantics to be inferred.

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

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

The description states a specific verb ('Get') and resource ('post engagement metrics'), and lists the metric types (likes, comments, shares) and grouping by date. It is clear what the tool does, though it does not explicitly distinguish itself from the sibling get_account_metrics or get_engagement_trend, which are related but different resources.

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

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

No guidance is provided about when to use this tool versus alternatives like get_account_metrics, get_engagement_trend, or get_stats_overview. The description implies it is for post-level metrics, but it does not state exclusions or conditions that would help an agent choose among the many metric-related siblings.

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

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

With no annotations, the description must disclose behavior. It reveals that media_upload options are uploaded automatically when a URL is provided, including size limits, which is valuable. However, it doesn't mention whether the operation is read-only, potential side effects beyond uploads, or auth requirements.

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 efficient: the first sentence states the core purpose and examples, and the second adds necessary detail on media upload constraints. No fluff, well-organized, and the key usage guidance is front-loaded.

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

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

For a tool with one optional parameter and no output schema, the description covers usage, parameter semantics, and a key behavioral aspect (media upload). It doesn't specify the response format, but the purpose is clear enough that an agent can infer it returns a list of options. Given the simplicity, it's 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 schema has 0% coverage, so the description carries the burden. It explains that account_ids can specify specific accounts or, when null, all accounts, adding meaning beyond the raw type. It could be more explicit about how the parameter influences the response, but it adequately covers the main behavior.

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

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

The description clearly states the tool's purpose: retrieving supported custom options for posting, with specific examples (first comment, location, post as reel/story). It uses a specific verb 'get' and a clear resource, and is distinct from siblings like create_post or get_post_metrics.

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

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

It explicitly advises 'Use this before creating a post to know what options are available,' giving clear timing guidance. It doesn't mention exclusions or alternatives, but no sibling tool serves a similar pre-post purpose, so the context is sufficient.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only lists the data categories returned but does not mention whether the data is aggregated across accounts, whether results are real-time or cached, or how date filters affect the output. For a tool with no annotations, this is a significant gap in transparency.

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

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

The description is a single sentence that is concise and front-loads the purpose. It lists the key data categories without extra fluff. However, it could be more structured by indicating the optional date parameters, but the simplicity is acceptable.

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 stats tool with two optional date parameters and no output schema, the description is incomplete. It doesn't explain the meaning of the date range, whether it applies to all categories, or how the data is aggregated. With no annotations and no output schema, the agent lacks crucial context on how to use the parameters and interpret results, making it incomplete for practical use.

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

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

Schema description coverage is 0%, so the description must compensate for the two parameters (date_from and date_to). It does not mention them at all, leaving the agent to guess their purpose and format. While the parameter names are somewhat self-explanatory, the description adds no value beyond the schema, which is empty of descriptions. Given low coverage, the score is penalized but baseline 3 is used because the parameter names are reasonably clear.

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

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

The description clearly states the tool fetches an overall stats overview with specific components (unread feeds, pending posts, failed posts, inactive accounts), which distinguishes it from more specific stats tools like get_account_metrics or get_engagement_trend. However, it does not explicitly name any sibling as an alternative, so it doesn't fully differentiate itself from all possible overlaps.

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 for getting a high-level stats summary, but it does not specify when to use this versus get_account_metrics or get_engagement_trend. There is no explicit guidance on context, prerequisites, or when not to use it. The tool name and description suggest it's for a dashboard overview, but that is left to the agent to infer.

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

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

With no annotations, the description carries the full disclosure burden. It reveals that results are ranked by engagement metrics and filtered by date range, but it does not address sorting direction, defaults, permissions, rate limits, or whether any filtering or mutation side effects occur.

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 focused sentence that states the resource, selection logic, and temporal scoping without filler. It is maximally concise for the information it conveys.

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 five parameters prescriptions, no annotations, and no output schema, a one-sentence description leaves critical gaps: default date ranges, metrics syntax, account scoping, and response shape. This is under-specified for an agent to invoke reliably.

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 0%, so the description must clarify the five parameters, but it only implies date filtering and engagement-based ranking. It does not explain metrics format, limit semantics, or account_ids behavior.

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

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

The description uses a specific verb with a clear resource: 'Get top performing posts by engagement metrics for a date range.' It clearly conveys the operation and selection criterion, though it does not explicitly contrast itself with sibling tools like get_post_metrics or list_posts.

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

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

No guidance is given about when to choose this tool over siblings such as get_post_metrics, list_posts, or get_stats_overview. The description implies a use case for ranking posts, but there are no exclusions, prerequisites, or alternative-selection cues.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose an important behavior: results include team-shared accounts, not just personal accounts. However, it does not mention pagination, response format, authentication requirements beyond the phrase 'authenticated user,' or any rate-limit considerations, so some behavioral transparency is missing.

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

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

The description is a single concise sentence that front-loads the action and resource, then adds the important scoping detail about shared accounts. Every word earns its place with no redundancy or filler.

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

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

For a simple, zero-parameter list tool, the description is largely complete: it names the resource and the exact inclusion scope. It could be slightly richer by mentioning that search_accounts is the filtering alternative, but the absence of an output schema and the low complexity keep the gap small.

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

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

The tool has zero parameters and the input schema confirms this with 100% coverage. The baseline for zero-parameter tools is 4, and the description correctly adds no parameter details since there are none. There is nothing more to explain.

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

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

The description clearly identifies the operation ('List'), the resource ('social media accounts'), and the exact scope ('accessible to the authenticated user, including accounts shared via teams'). This distinguishes it from sibling tools like search_accounts, update_account, and delete_account, which perform different operations or narrower lookups.

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 tool is for retrieving the complete set of accessible accounts, but it does not explicitly state when to choose it over search_accounts or other listing tools. There is no mention of alternatives or exclusion criteria, leaving the usage context implicit rather than explicit.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool lists tools with names, descriptions, and input fields, and that it can filter by keyword. However, it does not mention whether the list is paginated, whether it includes disabled tools, whether it triggers any side effects, or what the exact response shape is.

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

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

The description is two sentences, front-loads the main purpose, and uses parenthetical examples to clarify scope. It is concise and readable, though the second sentence could be more specific about the filter behavior.

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

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

For a simple list tool with one optional parameter and no output schema, the description is mostly adequate. However, the lack of any behavioral details (pagination, ordering, whether the list is exhaustive) and the absence of explicit guidance on when to use this vs. use_ai_tool leaves some gaps for an agent.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain the 'query' parameter's purpose ('Optionally filter by keyword'), which adds meaning beyond the bare schema. However, it does not specify the expected format, case sensitivity, or matching behavior, leaving some ambiguity.

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

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

The description states a specific verb ('List') and resource ('AI content generation tools'), and enumerates examples (caption writers, hashtag generators, content ideas). It is clear what the tool does, though it doesn't explicitly differentiate from siblings like use_ai_tool or get_post_options.

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

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

The description implies usage: call this to list available AI tools, optionally filtering by keyword. It does not explicitly state when to use this versus use_ai_tool or other listing tools, but the context of 'AI content generation tools' provides reasonable guidance.

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

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

With no annotations, the description carries the full burden. It states a read operation (list) but does not disclose behavioral traits such as pagination, rate limits, or the nature of the return (e.g., an array of automation objects). The description is not misleading but lacks depth beyond the obvious.

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

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

The description is a single sentence, directly states the action and scope, and has no filler. It is front-loaded with the verb and resource, making it efficient.

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

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

For a simple list tool with no parameters and no output schema, the description is largely sufficient. It could explicitly mention the return type (e.g., a list of automations), but the intent is clear. Minor gap for an agent needing to know what it returns.

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

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

The tool has zero parameters, so the schema covers all parameters (100%). Per the baseline rule for 0 parameters, a score of 4 is appropriate since the description doesn't need to add parameter semantics.

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

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

The description clearly states a specific verb (list), resource (automations), and scope (accessible by the authenticated user). This distinguishes it from siblings like get_automation (singular) and toggle_automation (modification). 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 provides no explicit guidance on when to use this tool versus alternatives. It doesn't mention that this lists all automations while get_automation retrieves a single one, or that toggle_automation modifies. Usage is implied but not stated.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose pagination defaults, max per_page, search minimum length, allowed statuses, and date formats, but it does not mention return shape, ordering, default status behavior, authentication needs, or whether the operation is read-only.

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 dense sentence that front-loads the purpose before listing parameters. It is compact and covers all parameters without filler, though a structured list would improve readability.

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

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

The description covers all parameters and constraints, making invocation feasible, but it lacks usage guidance, output/return expectations, and any mention of permissions or edge-case behavior. For a simple list tool this is minimally adequate but leaves 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 0%, so the description must compensate, and it does: all 8 parameters are enumerated with types, defaults, and constraints such as max 100, min 3 chars, active/archived values, and YYYY-MM-DD formats. It adds meaning beyond the schema, though 'platform optional source key' is somewhat cryptic.

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

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

The description states a clear verb and resource: 'List items from a Listen stream.' It is not a tautology and distinguishes the tool from get_listen_stream and list_listen_streams by focusing on items, though it does not explicitly name sibling tools for comparison.

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 use this tool versus alternatives like get_listen_item or list_listen_streams. There are no exclusions, prerequisites, or decision rules, so an agent must infer usage from the name and context.

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

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

No annotations are present, so the description must carry the behavioral burden. 'List' implies a read-only operation, but nothing discloses pagination, output shape, or data source constraints. Since a listing operation is low-risk and side-effect free by convention, this is a minor but real 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?

One concise sentence with zero redundancy; the 'Params: none' note is arguably redundant with the schema but harmless and immediately scannable.

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

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

For a zero-parameter read-only list call, the description provides the essential action and resource. It could mention what constitutes a 'social listening source' or return behavior, but the low complexity makes this a minor omission rather than a blocker.

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

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

There are no parametersaging; the description explicitly states 'Params: none', which aligns with the empty input schema. No additional parameter semantics are needed.

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

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

The description clearly states the operation ('List') and resource ('social listening sources'). It does not explicitly distinguish these sources from sibling tools like list_listen_streams or list_listen_items, so it falls short of 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?

No guidance on when to use this tool versus alternatives. With siblings list_listen_items and list_listen_streams, an agent gets no criteria to decide which listing tool fits a request.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the result is scoped to the authenticated user, which is useful, but it does not mention pagination behavior beyond parameter defaults, ordering, or whether the response contains full stream objects or summaries. For a list operation, this is a moderate 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 a single sentence plus parameter details, with no wasted words. It is front-loaded with the core action and resource. However, the parameter details duplicate schema information, which slightly reduces 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 list tool with no annotations and no output schema, the description is thin. It does not describe the return shape, whether streams are paginated in a particular way, or how this relates to other list tools. An agent can call it, but it lacks context to interpret results or choose it confidently.

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 0%, so the description must compensate. It repeats the parameter names and defaults (page, per_page) but adds no meaning beyond the schema. It does not explain what page and per_page control in terms of result ordering or limits, so the agent gains little beyond the schema itself.

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

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

The description states a specific verb ('List') and resource ('Listen streams') and scopes it to the authenticated user. It is distinguishable from siblings like get_listen_stream (singular) and list_listen_items (different resource), though it doesn't explicitly name a sibling alternative.

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

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

The description implies usage context by scoping to the authenticated user, but it does not state when to choose this over list_listen_items or get_listen_stream. No explicit when/when-not guidance is provided, so the agent must infer from the resource name.

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

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

Since no annotations are provided, the description must carry the full burden. It discloses that the tool supports filtering by type, pagination, and account filtering, which are behavioral traits. However, it does not mention whether the operation is read-only, any authentication requirements, or the response structure, leaving some gaps.

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

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

The description is two concise sentences with no fluff. The primary purpose is front-loaded, and the supporting details are compact and easy to parse.

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 relatively simple list operation with 4 parameters and no output schema or annotations, the description covers the core functionality and key filtering options. It lacks details like response format, but given the simplicity, it is reasonably complete.

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

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

The description adds meaning beyond the schema by explicitly listing the type values (scheduled, draft, published, awaiting_approval) and mentioning 'pagination' (which covers page and limit) and 'account filtering' (which covers account_id). This compensates for the 0% schema description coverage by providing context for each parameter.

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

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

The description clearly states the verb ('List') and the resource ('posts'), and specifies the filtering criteria by type with explicit values (scheduled, draft, published, awaiting_approval). It also mentions pagination and account filtering, which differentiates it from sibling tools like list_queue_posts or list_top_posts.

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

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

The description provides clear context on when to use this tool: when you need posts filtered by type, pagination, or account. It does not explicitly state when not to use it or name alternatives, but the context is sufficiently clear to guide selection.

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

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

The description adds the behavioral detail of ordering by queue position, which is useful. However, with no annotations, it does not disclose pagination behavior (the schema has a limit with default 20), whether the operation is read-only, or any auth requirements. It carries some burden but leaves significant gaps.

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

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

The description is a single, efficient sentence with no filler. It is appropriately short for the tool's simplicity and front-loads the core purpose without unnecessary detail.

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

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

For a simple list tool with two parameters and no output schema, the description is partially complete. It covers the main function and ordering but lacks mention of the default limit (20), pagination behavior, and what the response contains. Given the lack of an output schema, the agent might not know what to expect in the return value.

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 0%, so the description must explain the parameters. It only indirectly references queue_id via 'specific custom publishing queue' but does not describe the format or constraints, and it completely omits the limit parameter. The agent receives no parameter guidance beyond the schema's field names and types.

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

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

The description clearly states the action: list posts in a specific custom publishing queue, with an explicit ordering by queue position. It distinguishes itself from siblings like list_posts by specifying the queue context, so an agent can tell it 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?

The description implies usage when a queue_id is known, but it does not explicitly state when to use this tool versus alternatives like list_posts or provide any exclusions. The context is clear but no guidance is given about when not to use it or when to prefer a different sibling.

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

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

No annotations are provided, so the description carries the full burden. 'List' implies a read-only operation, and the description doesn't mention any side effects, authentication requirements, or return format. It adds minimal behavioral context beyond the verb, though the operation is simple and self-evident.

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

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

Two sentences with no wasted words. The primary action is front-loaded, and the second sentence adds useful context about what queues are. Every sentence earns its place.

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

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

For a simple list tool with no parameters and no output schema, the description is complete. It explains the resource and its purpose, leaving nothing essential for an agent to call it correctly.

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

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

The tool has zero parameters, and the schema coverage is 100% (empty). Per the rubric, a parameterless tool gets a baseline of 4. The description doesn't need to explain parameters, and it doesn't, which is appropriate.

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

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

The description uses a specific verb 'List' with a clear resource 'all custom publishing queues' and scope 'for the authenticated user'. It distinguishes itself from siblings like list_queue_posts, which lists posts within queues, making the purpose unambiguous.

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

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

While it doesn't explicitly name alternatives, the description clearly implies this tool is for listing queues, not posts or other resources. The context is clear enough for an agent to infer when to use it versus siblings like list_queue_posts, though it lacks an explicit when-not-to-use note.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the scope ('authenticated user') but does not mention pagination, response format, potential errors, or whether any side effects occur. This is essentially a purpose statement rather than a behavioral disclosure.

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

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

The description is a single, front-loaded sentence with no filler or repetition. It clearly states what the tool does and the scope, making it concise and well-structured for a zero-parameter tool.

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

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

The tool is simple and has no parameters, so the description is mostly adequate for calling it. However, there is no output schema and no annotation; the description does not specify the return value shape, whether pagination is involved, or any other details an agent might need after receiving the result. It is minimally viable but leaves 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?

There are zero parameters and the schema is empty, so the baseline is 4. The description adds nothing about parameters because none exist, which is appropriate and requires no further explanation.

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

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

The description uses a specific verb and resource: 'List all teams the authenticated user belongs to.' It clearly scopes the operation to the current user and distinguishes it from search-based siblings like search_teams by emphasizing 'all' teams the user is a member of.

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 over alternatives. It does not mention search_teams, list_accounts, or any other sibling that might overlap. The intended context is only implicit in the wording.

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

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

With no annotations, the description must carry the transparency burden. It discloses that the action is immediate and targets scheduled/draft posts, but does not mention side effects such as status change, irreversibility, or behavior for already-published posts.

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 and scope are front-loaded, and every word contributes meaning.

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

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

For a one-parameter mutation with no output schema, the description covers the core action but leaves operational context implicit—no prerequisites, side effects, or exclusions. It is adequate for a simple tool but not fully complete.

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

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

Schema description coverage is 0% and the description never mentions post_id, adding no semantic detail beyond the parameter name. The name is self-explanatory, but the description fails to compensate for the missing schema-level documentation.

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

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

The description uses a specific verb ('publish'), a resource ('post'), and a condition ('scheduled or draft', 'immediately'). This clearly differentiates it from lifecycle siblings such as create_post, approve_post, add_post_to_queue, and delete_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 intended use case: publishing posts that are either scheduled or drafted and wanting them live now. However, it does not explicitly contrast with alternatives like approve_post or add_post_to_queue, nor provide when-not-to-use guidance.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It does not explain side effects (e.g., whether tokens are invalidated or a user must authorize), permissions required, or the nature of the returned URL. It only states the action without revealing any behavioral implications.

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

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

The description is a single, concise sentence that leads with the tool's purpose and then lists supported types. No filler or redundancy; 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 tool with two parameters and no output schema, the description covers the core purpose and supported types. It is adequate but lacks details on how the returned URL is used (e.g., whether it requires user interaction) and does not explicitly differentiate the reconnect flow from the initial connection flow.

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 has 0% description coverage, so the description must compensate. It adds value by listing all valid account types for the account_type parameter, which is directly relevant. However, it provides no explanation of account_id, leaving that parameter undefined. Partial compensation for one of two parameters.

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

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

The description clearly states the action (get OAuth URL) and resource (reconnect existing social media account). The term 'reconnect' differentiates it from the likely sibling get_account_connect_url, though it does not explicitly name that alternative.

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

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

Provides a specific use case ('e.g. after token expiry') which gives clear context, but it does not directly contrast with siblings like get_account_connect_url or state when *not* to use it. The guidance is implied rather than explicit.

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

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

With no annotations, the description carries the behavioral burden and does disclose a key trait: it is a mutating action gated by approval permission. However, it does not state what happens to the post after rejection, whether the action is reversible, or what response to expect.

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 conveys the action, the target state, and the permission requirement with no filler. Every clause earns its place and the most important information is front-loaded.

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

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

For a simple two-parameter mutation with no annotations and no output schema, it covers the core purpose and permission requirement but leaves the post-rejection outcome and expected response unstated. It is adequate but not fully self-sufficient.

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

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

Schema description coverage is 0%, so the description must add meaning to the parameters. It clarifies that 'reason' is part of the rejection, and 'post' implies post_id, but it never names post_id or explains where it comes from or what format reason should take.

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 ('Reject') with a clear resource ('a post that is awaiting team approval') and a clear required input ('with a reason'). It conveys the action precisely, though it does not explicitly call out the sibling approve_post as its opposite.

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

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

It states a clear precondition ('Requires approval permission in the team') and implicitly scopes the tool to posts awaiting team approval. It does not say when to prefer this over approve_post, delete_post, or update_post, leaving some routing to inference.

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

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

No annotations are provided, so the description carries the full burden. It discloses the search behavior and return fields, but doesn't mention whether the search is case-insensitive, partial vs exact match, pagination, rate limits, or what happens when no matches are found. For a read-only search tool, the lack of match semantics is a notable 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?

Two sentences, no filler, and the key action is front-loaded. It earns its place by adding return-field context, though it could be slightly more informative without becoming verbose.

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

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

For a single-parameter search tool with no output schema and no annotations, the description is thin. An agent needs to know match semantics (partial vs exact, case sensitivity) and what the response looks like beyond the listed fields. The description is adequate for a basic search but leaves important operational details unspecified.

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 0%, so the description must compensate. It says the query is a name to search for, which adds some meaning beyond the bare 'query' string property, but it doesn't specify format, minimum length, or whether it supports partial/fuzzy matching. The description adds minimal value over the schema.

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

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

The description states a specific verb ('Search') and resource ('connected social media accounts') and mentions the return fields (id, name, type, network). It is clear enough to distinguish from list_accounts, which presumably lists all accounts rather than searching by name, though it doesn't explicitly name the sibling.

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

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

The description implies usage: search accounts by name when you need to find a matching account. It doesn't explicitly state when to use this over list_accounts or other account-related tools, nor does it mention any exclusions or alternatives. The context is inferable but not explicit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Returns matching teams', leaving ambiguous whether matching is exact, substring, case-insensitive, or whether pagination, ordering, or rate limits apply. These details materially affect an agent's expectation and are not disclosed.

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

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

The description is two short sentences that are entirely on point: one states the operation and target, the other states the return. There is no filler, redundancy, or irrelevant detail.

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

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

For a tool with one parameter and no annotations or output schema, the description is minimally adequate but leaves key facts ambiguous, particularly the matching semantics. It covers the core function but does not fully prepare an agent to correctly interpret the meaning of a 'match' or know what response format to expect.

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

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

Schema coverage is 0%, so the description must add meaning to the sole parameter 'query'. It does state that the search is 'by name', which clarifies the semantic role of the query parameter. However, it does not specify match behavior (e.g., exact vs partial) or any constraints on the query length or format, so it only partially compensates.

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 the verb 'Search' and resource 'teams' and adds a filtering criterion ('by name'), which lets an agent distinguish it from list_teams without opening the schema. It does not explicitly call out the sibling difference, but the scoping to name makes the purpose unambiguous.

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

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

Usage is implied: an agent would search by name when they need specific teams matching a query. There is no explicit 'when to use list_teams instead' or 'use list_teams to get all teams', but the presence of sibling list_teams and the wording 'search' convey the primary distinction. No exclusions, alternatives, or prerequisites 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action ('Enable or disable') without revealing any side effects, permissions required, idempotency, or consequences of toggling. For a mutation tool, this is a significant 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 a single, concise sentence with no fluff, front-loading the action. It is efficiently written, though the extreme brevity sacrifices content—yet for this dimension, it earns credit for being tight and directly stating the core purpose.

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

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

For a simple mutation tool with no output schema and no annotations, the description is too minimal. It does not explain the effect of toggling, what the response will be, or any side effects. An agent has enough to call the tool but lacks critical context about behavior and results, making it incomplete.

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 0% and the description does not mention any parameters. The schema defines automation_id and enabled, but the description adds no meaning to them, leaving the agent to guess their roles or format. With two required parameters and zero description, this is a severe deficiency.

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 ('Enable or disable') and resource ('an automation'), making the action clear. It distinguishes from sibling tools like get_automation and list_automations by implying a state change, so an agent knows exactly what this 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?

There is no guidance on when to use this tool versus alternatives like get_automation or list_automations. The description implies usage when you want to change state, but it does not state conditions, prerequisites, or exclusions, leaving the agent to infer.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Unarchive' implies a state-changing mutation, but there is no mention of idempotency, what happens if the item is not already archived, permissions, or side effects.

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

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

The first sentence is a crisp purpose statement and the second sentence is succinct. However, it repeats schema information (required integer types) that adds no 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 mutation with no annotations and no output schema, the description lacks guidance on expected effects, error conditions, or prerequisites. Although the operation appears simple, the definition leaves the agent without enough context to invoke it confidently.

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

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

The description restates the schema's required integer types without adding meaning: it never explains that stream_id identifies a Listen stream or that item_id selects the target item. With 0% schema description coverage, the description should compensate but does not.

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

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

The verb 'unarchive' plus resource 'one item in a Listen stream' precisely identifies the operation and differentiates it from sibling tools like archive_listen_item and bulk_archive_listen_items. The scope 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 states the operation and scope ('one item') but never explicitly says when to choose this over bulk_archive_listen_items or archive_listen_item. No alternatives or exclusion conditions are mentioned, so usage guidance is implied rather than stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action 'update the display name' without revealing side effects, permission requirements, reversibility, or error behavior. This is a minimal disclosure for a mutation tool.

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

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

The description is a single, focused sentence with no filler. It front-loads the core action and resource, making it immediately readable and scannable for an agent.

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 update, the description covers the core action but omits context such as error handling, success/failure behavior, and any connection prerequisites (suggested by the sibling 'reconnect_account'). It is minimally adequate but not complete for a mutation tool with no annotations or 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?

The schema has 0% description coverage, so the description must explain the parameters. It implicitly ties 'name' to 'display name', which adds some meaning, but it does not clarify constraints (e.g., length, format) or the purpose of 'account_id' beyond being an identifier. The description does not sufficiently compensate for the absent schema descriptions.

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

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

The description clearly states the verb 'update' and the resource 'display name of a connected social media account'. It is specific and distinguishes from siblings like delete_account, reconnect_account, and update_post, leaving no ambiguity about what this 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 provides no guidance on when to use this tool versus alternatives such as reconnect_account or update_post. There is no mention of prerequisites (e.g., account must be connected) or scenarios where this tool is not appropriate, leaving the agent to infer usage from the action alone.

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

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

No annotations are present, so the description takes on the full burden. It clearly states this is a mutation, what can be changed, and the draft-to-scheduled conversion behavior. It does not mention permissions or reversibility, but it does make the operational effects largely predictable.

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

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

The description is three short, purpose-driven sentences with no filler. It opens with the primary action, then covers the conversion rule and allowed post_type values, each sentence adding necessary operational detail.

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

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

For a mutation with five parameters, no output schema, and no annotations, the description provides enough guidance to invoke the tool correctly: which fields can be updated, the allowed post_type values, and the conversion specifics. It does not cover error conditions or edge cases like published posts, but the stated scope keeps those gaps minor.

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

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

Schema description coverage is only 20% (only options has a schema description), so the description compensates by explaining the format of scheduled_at, the JSON-encoded nature of options, and the valid values for post_type. It does not explain content format or the meaning of omitting fields, but it covers the least obvious parameters.

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

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

The description names a specific action ('update'), a specific resource ('a scheduled or draft post'), and enumerates the changeable fields. It clearly distinguishes itself from create/delete/publish siblings by limiting scope to scheduled or draft posts, though it does not explicitly contrast it with any sibling.

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

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

It gives concrete instructions: to convert a draft to a scheduled post, set post_type to scheduled and provide scheduled_at, and it constrains post_type to scheduled or draft. It does not explicitly say when not to use it (e.g., 'use publish_post_now instead'), but the usable scenario is clear enough.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the tool executes generation and returns content, but it does not disclose possible side effects, rate limits, cost implications, or whether the operation is asynchronous or immediate. For an execution-like 'Run' tool, this is a meaningful transparency 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 two compact sentences with no filler. The first sentence identifies the action and the origin of the slug; the second explains the inputs format and the return value. Each sentence earns its place.

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

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

The description covers the return value, which is helpful given the absence of an output schema. But with no annotations, it leaves out behavior and failure modes, and it does not explain how the returned content relates to other tools like create_post. It is adequate for a simple runner but not rich.

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 50% — only inputs has a description, while tool_slug is bare. The description adds meaning to tool_slug by tying it to list_ai_tools and clarifies that inputs are 'a JSON-encoded object keyed by field ID'. It partially compensates for the schema gap but does not elaborate on expected value formats or how field IDs relate to the tool's own fields.

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

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

The description states the specific verb 'Run' with a resource 'AI content generation tool' and identifies the selection key 'slug'. It also points to list_ai_tools as the source of that slug, which partially distinguishes it from list_ai_tools (a listing tool), though it does not explicitly contrast it with content-creation siblings like create_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 phrase '(from list_ai_tools)' implies a prerequisite: first call list_ai_tools to obtain a valid slug. However, the description does not state when to use this tool versus other content creation or generation tools, nor does it give explicit exclusions. Guidance is only implied, not explicit.

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