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

No annotations are provided, so the description carries the full burden. 'Assign' implies a write operation, but it does not disclose effects (e.g., whether it overwrites existing assignments), permission requirements, or reversibility. The description is too sparse to convey behavioral traits beyond the basic 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 a single, concise sentence with no wasted words. It is front-loaded with the action. However, it is so brief that it sacrifices necessary detail, though for conciseness alone it scores well.

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 two required parameters and no output schema or annotations, the description is insufficient. An agent does not know what the parameters refer to, what the tool returns, or how it fits into the broader workflow (e.g., whether accounts must be connected first). Minimal context is provided.

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 either parameter. The schema only provides names and types, leaving teamId and accountId without any semantic explanation (e.g., what they reference or any constraints). The description adds no 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 'Assign an account to a team' clearly states a specific action (assign) on two resources (account, team). It distinguishes from the sibling remove_team_account, though it could be more explicit about the nature of the relationship (e.g., linking an existing account to a team). Not a tautology; it adds meaning beyond the name.

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. The sibling remove_team_account exists, but the description does not mention any exclusions, prerequisites, or typical scenarios. An agent must infer the appropriate context 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, the description must carry behavioral disclosure. 'Verify' strongly implies a read-only diagnostic, and the listed items clarify scope, but the description does not explicitly confirm non-mutation, nor does it explain failure behavior or what happens if checks fail.

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

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

Two sentences with zero filler: the first states what the tool verifies, the second states when to use it. Every word earns its place, and the key information is front-loaded.

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

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

For a no-input diagnostic, the description provides enough to select and invoke it correctly: it names the checks performed and says to run it first. It does not describe the response shape, but the absence of an output schema and the simplicity of the call make this a minor gap rather than a blocking one.

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 sketchy so the schema is fully covered by its empty parameter list. The description adds no parameter details, and none are needed; baseline 4 is appropriate.

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

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

The description identifies a specific verb ('Verify') and concrete resources: API key, connectivity, connected accounts, and quota. This unambiguously distinguishes it from the many data and mutation sibling tools, and 'Run this first' reinforces its preflight role.

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

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

The description gives explicit when-to-use guidance: 'Run this first before any other tool.' It does not name alternatives or state when not to use it, but the precedence instruction is clear and actionable.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses that the user must open the URL in a browser, signaling this is not a direct connect. However, it doesn't disclose side effects (e.g., whether a pending connection is created server-side), URL expiration, or return value.

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 tight sentence delivers the core function and the browser hand-off. 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?

The tool is simple, but with no output schema and no annotations, the description leaves gaps: it doesn't state the return format (presumably the URL), how client affects the URL, or whether any server-side record is created. It adequately orients the agent but is not complete enough for confident invocation without further steps.

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 50% (platform has a description, client does not). The description does little to clarify parameters; it only mentions 'platform' generically. It omits the meaning of client (web/mobile) and doesn't compensate for the undocumented 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?

States a specific verb ('Build') and resource ('OAuth authorize URL') plus the goal ('to connect'). Distinguishes from sibling account tools (list_accounts, get_account, disconnect_account) by focusing on the authorization initiation step.

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

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

The description implies a use case (initiating account connection) but provides no explicit guidance on when to choose this over alternatives like list_accounts or refresh_account. It doesn't state prerequisites, such as invoking describe_platform first, though the schema hints at it.

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

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

No annotations exist, so the description carries the full burden. It discloses the scheduling behavior (omit for immediate, parentCommentId for reply) and that this is a creation action, but it does not address side effects, failure modes, authentication, or return values.

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 entire description is one sentence, front-loading the core action and then adding the two optional-behavior clauses without padding.

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 5-parameter mutation with no annotations or output schema, the description covers the primary behavior and optional modes, but lacks details on response, error conditions, and constraints on posting (e.g., cannot reply to non-scheduled comments).

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 40%; the description compensates by explaining the two most ambiguous parameters: scheduledAt controls immediate vs. scheduled publishing, and parentCommentId enables replying to a scheduled comment. postId and text are self-explanatory and accountId already has a schema description.

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

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

Description opens with a specific verb-resource pair ('Create a comment on a post') and clarifies the acting account. It further distinguishes the scheduling and reply modes, setting it apart from post-creation and comment-edit 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 explains when to omit scheduledAt (immediate publish) and when to pass parentCommentId (reply to a scheduled comment). While it doesn't explicitly name alternative tools like update_comment or delete_comment, the context is clear enough for tool selection.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose two key behaviors: the post is saved as a draft and is not scheduled. However, it does not mention side effects, permissions, validation failures, or whether anything is immediately published to connected accounts.

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

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

Two short sentences with no wasted text. The most important behavioral distinction (draft, no scheduledAt) is front-loaded, and the prerequisite instruction is placed second. 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 tool with 7 parameters and no output schema, the description is thin. It correctly flags the draft behavior and the describe_platform prerequisite, but it does not describe the return value, what happens after creation, or how the many optional fields fit together. Still, the schema fills some gaps, so it is minimally viable.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds contextual value by pointing to describe_platform for per-platform required fields, but it does not explain how parameters like threadParts or accountOverrides interact beyond the schema.

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

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

The description clearly identifies the operation as creating a post and immediately disambiguates it from scheduled publishing by noting it saves as a draft with no scheduledAt. This distinguishes it from sibling tools like schedule_post without needing to inspect schemas.

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

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

The description gives explicit pre-use guidance: 'Call describe_platform first for per-platform required fields.' It also implies when not to use this tool by stating draft-only behavior and no scheduledAt, though it does not explicitly name schedule_post as the alternative.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It specifies input sources and columns but does not disclose whether this creates an import job or posts directly, error handling, permissions, or async processing. For a mutation tool with no annotation safety net, 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 two concise sentences with no filler. The primary action and input methods are front-loaded, and the column information is valuable without being verbose. Every phrase earns its place.

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

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

With no output schema and no annotations, the description omits critical outcome details. It does not state whether the call returns an import ID, processes asynchronously, or immediately creates posts. Given the sibling tools (list_post_csv_imports, retry_post_csv_import), this ambiguity could lead to incorrect agent behavior.

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

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

Schema coverage is 100%, so the schema already clearly defines the two parameters. The description adds meaningful context by indicating the 'or' relationship between csv and url (implying mutual exclusivity) and by stating the required columns (caption and accountId), which are not present in the schema. This goes beyond what the schema alone provides.

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

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

The description clearly states the action and resource: 'Bulk-create posts from CSV text or a public CSV URL.' It also names the expected columns. However, it does not explicitly distinguish itself from sibling tools like create_post or schedule_post, so an agent must infer the difference from the word 'bulk' and 'CSV'.

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

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

The description implies usage for bulk creation via CSV, but does not explicitly state when to use it over alternatives such as create_post, nor does it provide exclusions. The context is clear enough to infer a batch scenario, but no direct guidance or alternative routing is given.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Create' implies mutation, but the description does not state required inputs, uniqueness expectations for slug, side effects of assigning accounts, permission requirements, or what happens after creation. It is not misleading, but it is far too sparse.

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 wasted words and the main point is front-loaded. It earns its place by adding the account-assignment option beyond the title, though it is brief to the point of omitting useful 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?

For a mutation tool with five parameters, no schema descriptions, no output schema, and no annotations, the description is incomplete. An agent is left without enough information about required parameters, side effects, or how this tool relates to sibling team tools such as add_team_account and update_team.

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. The phrase 'optionally assigning accounts' adds some meaning to accountIds, but it provides no semantic detail for name, slug, avatarUrl, or description. Parameter names are somewhat self-explanatory, but slug in particular needs clarification and does not receive it.

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

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

The description states a specific action and resource: 'Create a team', and adds one key variant, 'optionally assigning accounts'. However, it does not explicitly distinguish this from closely related sibling tools like add_team_account or update_team, so it is clear but lacks sibling differentiation.

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 guidance about when to use this tool versus alternatives. It does not mention that it is for creating a new team rather than updating an existing one, nor does it explain when the optional account assignment should be used instead of add_team_account.

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 of explaining behavioral traits. It identifies the target as 'pending' but does not disclose that deletion is destructive and likely irreversible, what permissions are required, or whether deleting a pending comment affects replies or related data.

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 short sentence with no filler. It earns its place by adding the important 'pending' qualifier, though it is close to a restatement of the title.

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 one-parameter tool with no annotations and no output schema, the description is underequipped. An agent can guess the basic action but lacks information about the pending-state constraint, failure cases, and consequences of deletion.

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 needed to compensate by explaining commentId, but it does not. The parameter name is reasonably self-explanatory, yet the description adds no meaning about the id format, source, or how to obtain it.

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

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

The description uses a specific verb ('Delete') and a specific resource ('a pending comment'), which makes the core action clear. The qualifier 'pending' adds scope that helps distinguish it from general comment operations, though it doesn't explicitly name or contrast sibling tools.

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

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

The description gives no guidance on when to use this tool versus alternatives like update_comment, retry_comment, or delete_post. It implies the comment must be pending but never states what to do for non-pending comments or why this tool is the right choice.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states the action with no mention of permanence, irreversibility, permissions, or effects on associated data, leaving the destructive nature implied by the verb alone.

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 core action and scope are front-loaded, and every word contributes to the 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 deletion tool this is nearly adequate, but without annotations or an output schema the agent is left to infer success/error behavior and whether deletion is permanent. It also does not point to related tools for discovering mediaId.

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 explain mediaId's format, origin, or how to obtain it. The parameter name is somewhat self-explanatory, but the description adds no semantic value beyond the schema.

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

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

The description uses a specific verb ('Delete') and resource ('one media item'), clearly distinguishing this from delete_media_many (one vs many) and from media-read/upload tools. The singular scope is explicit and unambiguous.

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

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

The description implies singular use with 'one media item,' but it does not explicitly reference alternatives such as delete_media_many or clarify when this tool should be chosen over them. Guidance is present only by implication.

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 behavioral disclosure burden. It clarifies that deletion is destructive and that results are reported per id, which is helpful. However, it omits whether deletion is irreversible, how partial failures are handled, or any auth/permission 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?

A single, front-loaded sentence with no filler. Every word carries meaning: the action, the batch scope, and the response 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 destructive tool with no annotations and no output schema, this is only minimally complete. It states the core behavior and the fact of per-id reporting, but leaves the outcome format, partial failure semantics, and permanence of deletion unexplained.

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 connects mediaIds to 'media items', giving minimal semantic grounding beyond the property name. It does not explain ID format, whether invalid IDs cause errors, or how the per-id outcomes map to the request ordering.

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

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

States a specific verb and resource: 'Delete several media items'. The batch scope ('several') and the per-id outcome reporting distinguish it clearly from the sibling delete_media tool. An agent can tell what it does without inspecting 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 'Delete several media items' implies it is for batch deletion, which is useful but not explicit. It does not mention when to use this instead of delete_media, nor does it state any exclusions or failure conditions.

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 responsibility for behavioral disclosure. It reveals the conditional scope of deletion (draft/scheduled only) and that published posts are untouched, which is valuable. However, it omits other behavioral traits such as irreversibility, permission requirements, or side effects on associated data.

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

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

The description is a single, efficient sentence that leads with the verb 'Delete' and adds only a necessary scoping qualification. Every word earns its place and there is no redundancy.

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

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

For a simple delete tool with one parameter and no output schema, the description supplies the key contextual information: what can be deleted (draft/scheduled) and what cannot (published). It lacks a brief note on effects (e.g., confirmation, permanence) but is otherwise 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?

There is only one parameter (postId) and schema description coverage is 0%, so the description must compensate. It adds meaning by restricting the post to be in draft or scheduled status, which informs what postId should reference. Still, it does not explicitly define postId or explain where to obtain it, though the tool name and single-parameter schema make this largely unambiguous.

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 'Delete', the resource 'post', and the scope 'draft/scheduled', while explicitly excluding published posts. This clearly distinguishes it from sibling tools like delete_comment or delete_media and clarifies that it does not affect published content.

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 provides when-to-use by restricting to draft/scheduled posts and when-not-to-use by stating published posts are kept. However, it does not name an alternative tool for deleting or unpublishing published posts, leaving that routing to the agent's 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 of behavioral disclosure. It only says 'Delete' and does not explain whether deletion is permanent, whether it fails if the team still owns accounts, what permissions are required, or what the response/error behavior looks like.

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 wasted words. The key scoping condition is placed immediately after the verb. It is concise, though it sacrifices behavioral 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 destructive tool with no annotations and no output schema, the description is too thin. It states a precondition but omits consequences, failure cases, and expected result format, which an agent would need to invoke and interpret the tool correctly.

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

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

Schema description coverage is 0%, and the description does not mention teamId at all. The property name is somewhat self-explanatory, but the description adds no meaning about how to identify the team, what format the ID takes, or how the ownership condition relates to the 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 ('Delete') and resource ('team'), and adds a precise scoping condition: 'that no longer owns accounts.' This distinguishes it from sibling tools like update_team, remove_team_account, and get_team, so the agent can select it correctly.

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 'that no longer owns accounts' implies the precondition for deletion, giving some context on when this tool is appropriate. However, it does not explicitly state when not to use it or mention alternatives such as remove_team_account for teams that still own accounts.

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 behavioral disclosure burden. It effectively discloses that the tool is local and side-effect-free by stating 'Offline — no API call.' This is meaningful additional context beyond the schema, even if it does not detail return formatting or latency.

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

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

The description is two sentences with no filler. The core purpose is front-loaded, followed immediately by the most important usage guidance and a note about being offline. 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-optional-parameter tool with no output schema, the description covers the tool's purpose, its intended position in a workflow, and its offline/safe nature. It does not describe the exact shape of the returned schemas, but it names what the output contains ('publish field schemas and adapter capabilities'), which is likely enough 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?

Schema description coverage is 100%, so the schema already documents the platform parameter, including the list of valid keys and the behavior when omitted. The description adds only the general context of per-platform behavior, which is useful but does not substantially extend the schema's 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 states a specific verb and resource: it returns 'per-platform publish field schemas and adapter capabilities.' It also clarifies how this tool relates to content-publishing actions by explicitly mentioning create_post/create_comment, making it easy to distinguish from the many post/comment tools in the sibling list.

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

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

The description gives an explicit usage trigger: 'Call before create_post/create_comment to learn required fields.' It does not name alternatives or exclusions, but it provides clear context for when this tool should be invoked, which is sufficient given there are no similar discovery tools among 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 carries the full disclosure burden. It explicitly warns that disconnecting cascades to pending schedules, comment automation, inbox, goals, and agents, while clarifying that published history is kept. It does not cover permission requirements or reversibility, but the major destructive side effect is transparently stated.

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

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

Two sentences, with the action first and consequences second. Every word contributes value, 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 one-parameter tool with no output schema, the description covers the core action and the most important side effects. It could briefly state what 'disconnect' means operationally, but the cascading detail already gives an agent enough to predict the outcome.

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 single accountId parameter. It does not explicitly define what accountId is or where to find it, though it is inferable from the tool name and text. The description adds no format, source, or validation detail.

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 ('Disconnect an account') and adds distinguishing details about cascading effects and retained history. This clearly separates it from siblings like connect_account or refresh_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?

Usage is implied: use this when you need to disconnect an account. However, there is no explicit 'use when', no mention of when not to use it, and no alternatives are suggested. The cascading behavior hints at consequences, but not at when the tool should be selected over others.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals a key behavior: non-Facebook platforms return an error. But for a mutation tool, it fails to disclose consequences like irreversibility, permission requirements, or whether the original message is overwritten, which is inadequate for safe invocation.

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

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

A single sentence that front-loads the action and adds a critical platform constraint in a parenthetical. Every word is necessary; there is 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 three-parameter mutation tool with no annotations, no output schema, and zero schema description coverage, this description is too sparse. It omits parameter semantics, side effects, and any prerequisites or return information, leaving an agent to guess critical invocation details.

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

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

Schema coverage is 0% and the description adds no parameter details. The parameter names (itemId, replyId, message) are somewhat self-explanatory, but without any definition, an agent must infer the distinction between itemId and replyId and the expected format of message. The description does not compensate for the lack of 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 states a specific verb ('Edit'), resource ('a reply already sent'), and scope ('currently Facebook only'), clearly distinguishing it from sibling reply_to_inbox_item which sends a new reply. The platform limitation is also specified.

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

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

The description gives clear context: it edits an existing reply and is currently Facebook-only, with other platforms returning an error. This implies the tool is for modifying sent replies rather than creating them, and explicitly excludes non-Facebook platforms, though it does not name alternative tools directly.

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

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

The description adds useful behavioral context by naming the returned fields and token health details, and 'get' implies a read-only operation. However, with no annotations and no output schema, it does not disclose behavior for invalid/missing account IDs or whether only currently connected accounts are returned.

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

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

The description is a single dense sentence that front-loads the tool's target and lists the key returned fields with no filler. Every part 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 getter, the field list provides a reasonable sketch, but the absence of annotations, output schema, and any usage or error context leaves an agent guessing about where accountId originates and what happens on failure. It is minimally adequate but not complete.

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

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

Schema coverage is 0% and the description never mentions accountId, so the parameter's meaning is left entirely to its name. It would benefit from a note that accountId is the ID of a connected account, ideally pointing to list_accounts as its source.

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

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

The description clearly identifies a single connected account and enumerates its contents (profile, follower count, token health), distinguishing it from list_accounts and get_account_analytics. It uses a noun phrase rather than an explicit verb, but the title 'Get account' supplies the action.

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

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

There is no guidance on when to use this tool versus alternatives like list_accounts or get_account_analytics. It also fails to mention that the accountId should come from list_accounts or connect_account, leaving selection up 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 of behavioral disclosure. 'Engagement summary over a window' implies a read operation, but it does not disclose whether data must be refreshed first, whether a default window applies, what metrics are included, or whether this call has any 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 description is a single, front-loaded sentence with no filler or repetition. It is appropriately brief, though the brevity comes at the cost of useful detail that other dimensions penalize.

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 annotations, this description is not complete enough for an agent to confidently invoke the tool. It does not clarify the return shape, the role of windowDays, or how it differs from the many sibling analytics tools, which is a significant gap for a 2-parameter read endpoint.

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 sparse parameter documentation. It loosely maps 'account' to accountId and 'window' to windowDays, but it does not explain the expected format of accountId, the unit of windowDays, or any default 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 identifies a specific resource ('an account') and outcome ('engagement summary over a window'), so an agent can tell it is an account-level analytics read. However, it does not explicitly distinguish it from analytics siblings like get_analytics_summary or get_best_times, so it is clear but not fully differentiated.

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

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

There is no guidance on when to use this tool versus the many sibling analytics tools, nor any indication of when it should be preferred over get_post_analytics or get_analytics_summary. The agent is left to infer appropriate usage from the name and one-line description.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only says 'latest analytics row per accessible account,' leaving undefined what an 'analytics row' contains, how 'accessible account' is determined, what happens when no accounts are accessible, and whether results are sorted or paginated. The 'window' is also ambiguous relative to the windowDays parameter. This falls short for a tool with zero annotation support.

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 8-word sentence with no wasted words and front-loads the primary result. It is appropriately concise, though the brevity comes at the cost of essential detail, which is penalized in other dimensions.

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 has no output schema and no annotations, so the description is the sole source of context. It leaves key concepts undefined: 'analytics row,' 'window,' and 'accessible account.' An agent could invoke the tool but would not know what to expect in return or how to interpret results, making it incomplete even for a simple one-parameter tool.

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

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

The schema has one optional integer parameter, windowDays, with 0% description coverage. The description only alludes to it with 'in the window,' omitting units, default behavior when omitted, and how it filters rows. Since the description is the only source of parameter meaning, this is a significant 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 states a clear resource ('analytics summary') with a specific scope ('per accessible account') and a temporal qualifier ('latest ... in the window'). It is understandable at a high level, but it does not explicitly differentiate itself from sibling analytics tools like get_account_analytics or get_bulk_post_analytics, so an agent must infer which one to choose.

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. The phrase 'per accessible account' implies cross-account aggregation, but no sibling tools are named, and there is no mention of conditions, exclusions, or prerequisites. An agent gets no help distinguishing it from get_post_analytics, get_account_analytics, or refresh_analytics.

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 reveals the data source (engagement history) and optional account scoping, but it does not state whether the operation is read-only, how the recommendation is computed, or what the response contains.

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 immediately conveys the core functionality. Every word earns its place, with no filler or repetition of the tool name.

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

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

For a tool with one optional parameter, no annotations, and no output schema, the description explains the purpose and parameter optionality, but omits the return value shape (e.g., list of times, timezone, scores). An agent must infer what the output looks like, which is a notable gap.

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

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

The single parameter accountId has no schema description, so the description's '(optionally per account)' adds meaningful semantics by indicating that the parameter is optional and filters results by account. This compensates for the 0% schema coverage, though it leaves the accountId format unspecified.

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 that the tool provides recommended posting times derived from engagement history, optionally scoped to a specific account. It identifies a distinct resource ('best times') and distinguishes itself from sibling analytics tools like get_post_analytics, though it uses a noun phrase rather than an explicit verb.

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 guidance on when to use this tool versus alternatives, no exclusions, and no prerequisites. The only contextual hint is '(optionally per account)', which is parameter-level guidance rather than usage direction.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It discloses a useful behavioral trait: per-post errors are included, which tells the agent that partial failures are possible. However, it does not disclose whether this is a read-only operation, whether it requires any special permissions, or what the response shape looks like.

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 short sentence that front-loads the key constraint (up to 60 posts) and the notable behavior (per-post errors included). It is appropriately sized for a simple one-parameter tool, though it could have used the space to add more behavioral 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?

For a one-parameter read-style analytics tool, the description is mostly adequate: it states the resource, the batch limit, and the error behavior. However, with no annotations and no output schema, it leaves the agent without information about the response format, whether the operation is read-only, or how per-post errors are represented. The sibling get_post_analytics exists, so a brief contrast would have improved completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It does not explain the postIds parameter beyond what the schema already shows (array of strings, 1-60 items). The 'up to 60 posts' phrasing mirrors the schema's maxItems constraint, adding no new semantic meaning. The description adds no detail about what the post IDs refer to or how they are used.

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

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

The description states a specific verb ('get') and resource ('bulk post analytics') and adds a concrete scope ('up to 60 posts'). It is clear enough to distinguish from the sibling get_post_analytics, though it does not explicitly name that sibling or contrast itself with it.

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: it is for retrieving analytics for multiple posts at once, with per-post errors included. However, it does not explicitly state when to prefer this over get_post_analytics or get_account_analytics, nor does it mention any exclusions or prerequisites.

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 indicates a read operation via 'Fetch' but does not mention response format, error behavior, authorization requirements, or whether any 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?

The description is four words, front-loaded, and contains no filler. Every word earns its place and the core purpose is immediately visible.

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 getter, the basic call contract is present and usable. However, with no output schema and no annotations, the absence of return-value and behavioral information leaves gaps that a fuller definition could close.

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 adds no detail about the commentId parameter beyond what its name implies. This is a slight gap because the tool description should compensate for the undocumented schema, even for a single obvious 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 names a specific verb ('Fetch') and resource ('one scheduled comment'), and the singular scope clearly distinguishes it from list_comments and from object types like get_post or get_organization. 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?

No guidance is given for when to use this tool instead of alternatives such as list_comments or get_post. The agent must infer that this is the single-comment-by-ID lookup tool from the description 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?

Annotations are absent, so the description carries the full burden of behavioral disclosure. It only says 'Fetch one media item' and does not describe the response format, whether metadata or binary is returned, error behavior, or any access 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 one short sentence with no redundant words, and 'one' adds meaningful scope. It is appropriately concise, though minimal to the point of being under-specified for other dimensions.

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

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

For a one-parameter read tool, the description is minimally navigable, but with no annotations and no output schema it leaves the return value ambiguous and provides no differentiation from sibling tools beyond singular scope. An agent could call it from the schema alone but not confidently interpret the result.

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

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

Schema description coverage is 0%, and the description never mentions mediaId or explains how it identifies the media item. The property name is self-explanatory, but the description adds no semantic value beyond the schema.

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

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

States a specific verb ('Fetch') and resource ('media item'), and the modifier 'one' distinguishes it from list_media and other bulk operations. This is not a tautology of the title and clearly identifies the tool's 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?

No guidance is given on when to use this tool instead of list_media, upload_media, or delete_media. The singular 'one' weakly implies lookup by ID, but no explicit context, prerequisites, 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 carries the full burden. It does not disclose whether this is a read-only operation, whether it requires authentication, whether it can fail due to missing organization context, or what the response structure looks like. The description is a noun phrase and gives no behavioral detail beyond the data categories.

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

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

The description is extremely short and front-loaded, with no wasted words. It is arguably under-specified, but for a zero-parameter getter, brevity is acceptable. It could be improved by adding a verb and a sentence about when to use it, but it is not 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?

For a zero-parameter tool with no output schema and no annotations, the description should at least clarify that this is a read-only organization-level summary and how it relates to get_account/get_usage. The current description is too terse to fully orient an agent, especially with 50+ siblings.

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

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

The tool has zero parameters, so there is no parameter semantics burden. The description's mention of 'Plan, limits, and connected-account summary' helps set expectations for what the returned organization object contains, which is useful context even though no parameters exist.

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 'Plan, limits, and connected-account summary' names the resource (organization) and the kind of data returned, but it does not use a verb like 'get' or 'retrieve'. It is clear enough that this returns organization-level information, but it does not explicitly distinguish itself from get_account or get_usage, which could also involve plan/limits/account summaries.

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 on when to use this tool versus alternatives. Given siblings like get_account, get_usage, and check_setup, an agent would benefit from knowing that this is the top-level organization view and that account-specific details belong to get_account. The description only implies a general purpose.

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

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

With no annotations, the description carries the full burden, but it does not mention any behavioral traits like potential errors, performance implications, or authentication needs. It does state the return structure implicitly ('with its accounts... and media'), adding some context, but it omits the exact return format and whether the response is nested or flat. This is a slight gap for a read operation with no annotations.

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

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

The description is a single, concise sentence that front-loads the action and key content. There is no filler, and every word adds value. It is appropriately sized for the tool's simplicity.

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

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

Given the tool's low complexity (1 param, no output schema, no nested objects), the description is nearly complete for a read operation. It covers the return scope (accounts and media) but does not specify the response format (e.g., JSON structure) or potential errors, which would be helpful but are not critical for this simple fetch. Overall, it is adequate and nearly 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%, meaning the description must explain the parameter 'postId'. While the description refers to 'one post' and implies the postId identifies it, it does not explicitly state that 'postId' is the unique identifier or provide any format details. This is a baseline for a single obvious parameter, but it does not go beyond the schema's minimal 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 states a clear verb ('Fetch') and resource ('one post'), and specifies the return scope ('with its accounts... and media'), which distinguishes it from siblings like list_posts. However, it does not explicitly name what it is not (e.g., not fetching comments or analytics), though the mention of accounts and media sets 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 for retrieving a single post's details, which is the natural alternative to list_posts, but it provides no explicit guidance on when to use this tool versus siblings like get_post_analytics or list_comments. Context is clear from the name and description, but no exclusions or alternate routes are given.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates that the tool returns metrics and gives example metric names; it does not reveal whether the data is cached or real-time, whether it triggers a refresh, what happens for invalid/missing post IDs, or any auth/rate-limit 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 compact phrase with illustrative metric examples. Every word earns its place, and the core scope 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?

With no annotations and no output schema, the description should explain more about return shape and invocation context. It lists a few metrics but omits usage guidance, behavioral caveats, and parameter semantics, leaving an agent with only a minimal understanding of 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%, so the description must compensate. It does not explain postId beyond the parameter name and the general 'one post' phrasing; there is no guidance on ID format, where to obtain it, or how it relates to connected accounts.

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 'One post's metrics (likes, comments, reach, …)' uses a specific verb-resource pairing and clearly scopes the tool to a single post. This distinguishes it from siblings like get_account_analytics and get_bulk_post_analytics without needing to open their 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?

'One post's metrics' clearly implies the tool is for retrieving analytics for a single post. However, it does not explicitly mention when not to use it or point to get_bulk_post_analytics/get_account_analytics as alternatives, so it stops just 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it discloses nothing. It does not mention read-only semantics, authorization needs, error behavior for unknown jobId, or what the returned summary contains.

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

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

The description is extremely short, but this is under-specification rather than effective conciseness. It is a fragment that saves words by omitting essential information, so the brevity does not add value.

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

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

The tool is simple, but with no output schema and no parameter documentation, the description must explain what a 'summary' includes and how jobId is supplied. 'One import job's summary' provides minimal context but is not enough for an agent to confidently call the tool and interpret its 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 description coverage is 0%, and the one required parameter, jobId, is completely undocumented. The description does not compensate by explaining what jobId represents, where it comes from, or any format expectations.

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

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

The description is a noun phrase, 'One import job's summary,' rather than an explicit action statement, so an agent must infer the verb from the tool name. It does identify the resource and the singular scope, which weakly distinguishes it from list_post_csv_imports, but 'summary' is ambiguous and does not make clear what payload will be returned.

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 about when to use this tool versus related siblings such as list_post_csv_imports, get_post_csv_import_rows, or retry_post_csv_import. No context, prerequisites, or exclusions are provided.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It reveals that rows carry SUCCESS or FAILED statuses, which aligns with the status enum, but omits pagination behavior, default limits, ordering, and what row-level data accompanies each status.

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 front-loads the core output concept with no filler. It conveys the essential distinction and earns its place, though brevity comes at the cost of completeness in other dimensions.

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 paginated tool with 4 parameters and no output schema or annotations, the description is insufficient. Missing jobId provenance, pagination defaults, status filter defaults, and row payload details leaves an agent unable to confidently predict the response shape.

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% schema description coverage, and the description only maps 'import job' to jobId. Limit, offset, and the status filter semantics are not explained, and repeating SUCCESS/FAILED does not add meaning beyond the schema.

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

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

The description states the tool returns per-row SUCCESS/FAILED results for an import job, and the 'per-row' qualifier differentiates it from sibling get_post_csv_import, which likely returns job-level data. The title provides the verb and resource. Some vagueness remains about what fields each row contains, but the core purpose is clear.

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

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

No explicit guidance is given about when to use this tool versus get_post_csv_import or list_post_csv_imports. The phrase 'per-row' implies the intended use, but no alternatives, exclusions, or decision criteria are named, so the agent must infer the 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?

No annotations are provided, so the description must carry the full behavioral burden. It discloses only that the result contains a team and its member accounts; it does not state that the operation is read-only, what the response format is, or any error or permission characteristics.

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

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

The description is extremely concise at six words, with no filler or redundant phrasing. It is slightly too terse to earn a 5, but it is front-loaded 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 simple single-parameter read tool, the description plus the required teamId in the schema provide a minimally workable picture. However, with no output schema or annotations, the description does not fully explain the return structure, member account representation, or any operational context.

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

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

Schema description coverage is 0%, and the description does not mention teamId at all. The parameter name is somewhat self-explanatory, but with no schema descriptions and no description-level compensation, the agent gets little semantic guidance beyond the property name and 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 phrase 'One team with its member accounts' clearly identifies the resource and scope, distinguishing this from list_teams and get_account. However, it is a noun phrase rather than a statement with an explicit verb like 'get' or 'fetch', so it stops short of a fully specified purpose.

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?

Saying 'One team' implies retrieval of a single team, which imperfectly contrasts with the sibling list_teams. No explicit when-to-use guidance or alternative exclusions are provided, so the usage context is only implied.

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

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

With no annotations, the description carries the burden of disclosing behavior. It conveys that this is a read-oriented usage query by listing returned data, but it does not explicitly state that the call has no side effects, requires no parameters, or what happens if no usage data exists.

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

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

The description is a compact list with no filler or repetition. It could gain a little from being a full sentence, but it is appropriately sized for a no-parameter getter.

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 annotations, the description should specify what the agent will receive, which it does at a high level (usage, limit, balance). It leaves unstated the scope and the exact meaning of 'monthly post usage,' but it is adequate for a trivial getter.

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 complete for what exists, so the description has no parameter semantics to compensate for. The baseline 4 applies.

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

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

The description names a concrete resource (usage) and specifies three pieces of data: monthly post usage, plan limit, and credit balance. It stops short of an explicit verb, though the title's 'Get' supplies the action, and it is not clearly differentiated from analytics 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?

No guidance is given about when to call this tool instead of related tools such as get_analytics_summary or get_account. An agent is left to infer from the name that this concerns billing/limits rather than post performance.

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 return fields (id, platform, username) but does not mention whether the list is paginated, whether it includes disconnected/expired accounts, whether it requires prior authentication, or what happens when no accounts exist. For a read-only listing tool 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 compact sentence that front-loads the resource and includes the key return fields. It earns its place, though it could add a brief usage note 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?

For a simple list tool with one optional parameter and no output schema, the description is mostly adequate. However, the lack of any behavioral context (pagination, authentication, empty results) and the absence of explicit sibling differentiation leave minor but real gaps for an agent deciding whether to call 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?

Schema description coverage is 100%, so the schema already documents the platform parameter. The description adds the context that the result includes id, platform, and username, but does not explain the platform key values or the effect of omitting the filter. Baseline 3 is appropriate.

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

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

The description states a clear verb-resource pair ('List accounts') and specifies the scope ('Connected social accounts') with the fields returned (id, platform, username). It is distinguishable from siblings like get_account (single account) and connect_account (creation), though it doesn't explicitly name a 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 this is the tool for viewing connected accounts, and the optional platform filter suggests a use case. However, it does not explicitly state when to use this over get_account or list_account_tools, nor does it mention any exclusions or prerequisites.

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. 'Live lookups' hints at read-only, platform-specific data, but the description does not state that listing is non-mutating, whether an account connection is required, or what happens when no tools are available.

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

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

The description is a single compact sentence with useful examples and no filler. It is front-loaded with the key idea ('per-account live lookups') and easy to scan, though it sacrifices important guidance for brevity.

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 1-parameter list tool without an output schema, the description is still incomplete: it doesn't define what the returned list contains (tool names? endpoints? metadata?), nor how this relates to run_account_tool. An agent would need to guess the output shape and next steps.

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 for accountId, and the description only says 'Per-account' without explaining that accountId identifies the target account or clarifying expected format/value. The single parameter is inferable from context, but the description adds little beyond the schema.

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

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

The description states a specific resource ('per-account live lookups') and gives concrete examples (Reddit flairs, Pinterest boards), making the listing intent clear. It doesn't explicitly contrast with run_account_tool, but the title and examples are enough to identify the tool's purpose.

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 explicit when-to-use guidance or mention of alternatives. The phrase 'available for the account's platform' implies you'd call this before running a lookup, but the description doesn't say to pair it with run_account_tool, nor does it state when NOT to use it.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It does not explicitly state that this is a read-only listing operation, nor does it explain what happens with the status filter. The word "scheduled" actually creates ambiguity because the status enum includes published and failed, so the behavioral scope is unclear.

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

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

The description is very short with no filler or wasted words, and the key scope "for a post" is front-loaded. However, it is a fragment rather than a complete sentence, and its ambiguity means the brevity comes at the cost of clarity.

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, no output schema, and 0% parameter description coverage, this description is insufficiently complete. It does not explain the return format, the filtering semantics, or how the tool behaves relative to other comment tools. The agent would need to inspect sibling behavior or make risky assumptions.

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, but it only loosely maps "post" to postId and says nothing about the status parameter. It does not clarify that postId is required or what values like pending, published, and failed mean. The word "scheduled" does not match any enum value, adding confusion rather than clarity.

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

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

The description "Scheduled comments for a post" identifies a resource and scope, but it is a noun phrase rather than an explicit statement like "list comments for a post." It is ambiguous whether the tool returns only scheduled/pending comments or all comments, especially since the status enum includes published and failed. It vaguely distinguishes itself from siblings like get_comment and list_posts, but not clearly.

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 list_comments versus alternatives such as get_comment, retry_comment, or list_posts. The phrase "for a post" implies one use case, but the description does not state conditions, exclusions, or how the status filter should be used.

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, but it only discloses scope and item types. It does not mention whether this is read-only, how results are ordered, how pagination works, or what happens with mixed platforms/accounts. The phrase 'accessible accounts' adds some context but not enough behavioral detail.

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

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

The description is a single short sentence with no fluff, which is structurally concise. However, it is so sparse that it sacrifices useful content, making it minimally adequate rather than well-structured.

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

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

There is no output schema, no annotations, and no parameter documentation, so the description must provide nearly all the context needed for correct invocation. It only names item types and account scope; an agent cannot determine expected return shape, filtering behavior, or pagination semantics.

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 adds no meaning to any of the six parameters. limit, offset, status, platform, accountId, and sourceType remain unexplained except by their names and enums. The description must compensate for the missing schema descriptions 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 description clearly states the resource: 'Incoming comments, mentions, and DMs across accessible accounts.' The title and name reinforce the action of listing an inbox. It is distinguishable from siblings like list_comments by emphasizing cross-account inbox-style aggregation, though it does not 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?

No guidance is given about when to use this tool versus alternatives such as list_comments or reply_to_inbox_item. The description only states scope ('across accessible accounts') but does not provide conditions, prerequisites, or exclusion criteria.

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 disclosing behavior, but it only says 'List uploaded media'. It implies a non-mutating read operation but does not mention return shape, ordering, pagination behavior, or whether results are scoped to the authenticated account.

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 concise single sentence with no filler, and the core action is front-loaded. It is appropriately short, though it could carry more useful detail 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 tool with three optional pagination/filter parameters and no output schema, the description is incomplete. It omits result format, default ordering, pagination defaults, and how the type filter affects results, leaving an agent without enough context to reliably invoke and interpret 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%, and the description adds no meaning for the type, limit, or offset parameters. The agent must rely entirely on the schema's enum and numeric constraints; the description provides no additional parameter-level context.

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

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

The description states a clear verb ('List') and resource ('uploaded media'), matching the title and distinguishing it from singular get_media, upload_media, and delete_media at a basic level. However, 'media' is broad and no filtering or scoping details are included.

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 usage guidance is provided. The description does not say when to use this tool versus get_media for a single item, upload_media for adding media, or delete_media for removing media; an agent must infer the intended context from the tool 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?

No annotations are present, so the description carries the full behavioral burden. It discloses that only the caller's jobs are returned and that counts are included, but it does not describe ordering, read-only status, pagination behavior, or what the counts represent.

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 noun phrase with no filler and places the core object ('CSV import jobs') first. It is very efficient, though the efficiency comes at the cost of missing behavioral and pagination 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?

With no output schema, no annotations, and no parameter documentation, the description is too thin to fully support correct invocation. It gives a high-level sense of the result but leaves return shape, count semantics, and pagination 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%, and the description adds no meaning to 'limit' or 'offset' beyond their names and numeric constraints. With two undocumented parameters, 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 phrase 'The caller's CSV import jobs with counts' clearly identifies the resource and scope, and the title supplies the list verb. It is not a tautology and is readily distinguishable from create/retry/row-level import tools, though it does not explicitly call out those sibling distinctions.

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 about when to use this tool instead of get_post_csv_import, get_post_csv_import_rows, or retry_post_csv_import. It neither provides exclusions nor misleading advice, but leaves all tool-selection logic 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?

With no annotations, the description must carry behavioral disclosure. It only states the operation is a list with optional filters/pagination; it does not disclose ordering, defaults, post scope, authentication needs, or what happens when filters are combined. This is minimal behavioral context for a tool with no annotation safety cues.

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 tight, front-loaded sentence with no filler. It conveys the core operation and key modifiers without redundancy, though it is concise because of under-specification rather than completeness.

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 annotations and no output schema, the definition leaves out response shape, default pagination, and any list-scope details. For a tool used for retrieval, these are material gaps, so the description is not complete enough on its own.

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 documentation covers only q (25%), and the description does not compensate for the undocumented limit, offset, and status parameters. Calling these 'optional filters and pagination' gives a rough categorization, but not semantics such as how limit/offset behave or the meaning of the status values.

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 gives a clear verb-resource pair ('List posts') and mentions optional filters and pagination, which distinguishes it from singular/post-focused tools like get_post or create_post. However, it does not explicitly differentiate it from sibling list operations or specify the list's scope, 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 given about when to use list_posts versus a more targeted tool (e.g., get_post for a single post) or a filtered listing. The phrase 'optional filters' implies filtering, but there are no contexts, exclusions, or alternative tool mentions, so an agent must infer usage.

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

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

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 it returns all teams or paginated results, whether it requires authentication, or what the response shape is. The phrase 'with their member accounts' gives a small hint about the return content, but it is insufficient for a tool with no 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 extremely short and to the point, with no wasted words. It is front-loaded with the resource name. However, it is so brief that it reads as a fragment rather than a complete sentence, which slightly reduces its effectiveness.

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 list tool, the description is minimal but not entirely inadequate. However, with no annotations and no output schema, the description should clarify the return format, pagination, and whether member accounts are included in the response. The phrase 'with their member accounts' partially addresses the return content, but the lack of any behavioral or usage context 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?

The tool has zero parameters, so there are no parameter semantics to document. The description's mention of 'member accounts' adds some context about what the returned data contains, which is useful. With no parameters, the baseline is 4, and the description does not detract from that.

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 'Teams with their member accounts.' identifies the resource (teams) and hints at the return content (member accounts), but it lacks a verb. It does not explicitly state that this is a list/read operation, though the tool name 'list_teams' and title 'List teams' convey that. It is not a tautology, but it is a fragment rather than a clear statement of what the tool does.

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

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

There is no guidance on when to use this tool versus alternatives. Sibling tools like get_team, create_team, update_team, and delete_team exist, but the description does not distinguish list_teams from get_team or explain when to choose one over the other. The context is only implied by the name 'list_teams'.

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 disclosing side effectsched. It indicates the operation is server-side and involves OAuth token refresh, but it does not mention whether old tokens are invalidated, whether the account must be connected, what errors may occur, or any irreversible 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 description is a single, tight, front-loaded sentence with no filler. Every word contributes to naming the action, target, and location of the operation.

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

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

For a tool with no annotationsas and no output schema, the description is too minimal. It lacks usage context, side-effect details, and parameter clarification, leaving an agent with insufficient information 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 schema has 0% description coverage and the sole required parameter 'accountId' is not described in the tool description. The phrase 'an account's' loosely implies the parameter identifies the account, but the description adds no explicit meaning about format, requirements, or 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 specific action ('Refresh'), the resource ('an account's OAuth access token'), and the context ('server-side'). It is immediately distinguishable from sibling account-management tools like connect_account or disconnect_account and from refresh_analytics.

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 on when to use this tool, what prerequisites must hold (e.g., account must already be connected), or how it differs from alternatives. The description implies a token-refresh scenario but does not explicitly state it.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses that the operation is asynchronous and returns a job id, but it does not mention side effects, permissions, whether it overwrites existing analytics, or how to later retrieve the job result.

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 delivers the core operation, target resources, async nature, and return behavior with zero filler. Every element 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 tool has four undocumented optional parameters)Skip no output schema and no annotations, so the description must compensate for these gaps. It clarifies the high-level purpose but leaves critical invocation details unresolved, especially parameter semantics and whether postId or accountId is required.

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

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

Schema description coverage is 0% and the description only hints that postId and accountId correspond to 'post or account'. The limit and windowDays parameters are not explained, and there is no guidance on which parameter combination is expected or whether one of postId/accountId is required.

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 ('Enqueue'), a clear resource ('analytics backfill'), and the valid targets ('a post or account'). It also notes that a job id is returned, which distinguishes this async operation from synchronous analytics-fetch siblings like get_post_analytics and get_account_analytics.

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

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

The description implies the tool is used when an asynchronous analytics backfill is needed, but it does not explicitly explain when to prefer this over get_post_analytics, get_account_analytics, or refresh_account. No alternatives or exclusion conditions are named.

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 does disclose a key side-effect—the account is reassigned to the default team, not deleted—which adds value beyond the tool name. However, it omits other relevant behaviors such as required permissions, idempotency, or error handling when the account is not in the team.

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 core action comes first and the clarifying parenthetical is appended efficiently. 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 two-string-parameter tool, the description covers the primary behavior and the side-effect, but it leaves other aspects unstated: there is no output schema, no annotation, and no mention of what the tool returns, preconditions, or failure modes. An agent would need to infer these or test 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?

The input schema has 0% description coverage, and the description does not elaborate on teamId or accountId beyond the tool name and phrasing. The parameter names are self-explanatory, but the description adds no detail about formats, relationships, or semantics, so it fails to 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 action ('Remove') and resource ('account from a team'), and the parenthetical clarifies that removal means reassignment to the default team rather than deletion. This distinguishes it from related tools like delete_team or disconnect_account without needing to open the schema.

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

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

The description implies the tool is for removing an account from a team, and the reassignment note hints at the consequence. However, it does not explicitly name sibling tools such as add_team_account or state when this tool should be preferred over disconnect_account, leaving usage context implicit.

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. It only says 'Reply...' but does not disclose side effects (e.g., whether the inbox item is resolved, whether a notification is sent, or whether it can be used only once).

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

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

A single, front-loaded sentence with no filler. It is appropriately brief.

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

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

For a two-parameter mutation tool with no annotations, output schema, or parameter descriptions, this description is too thin. An agent cannot tell what itemId refers to, whether the reply overwrites an existing one, or how this differs from 'edit_inbox_reply'.

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 and the description adds no explicit meaning for 'itemId' or 'message'. Although parameter names are self-evident, the description does not clarify that itemId is the inbox item identifier or that message is the reply body.

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

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

States a specific verb ('Reply') and a resource ('a comment/mention/DM'), and the name/title ties it to inbox items. It is distinguishable from siblings like 'edit_inbox_reply' by implying creation of a new reply rather than modification.

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 versus alternatives such as 'edit_inbox_reply' or 'create_comment'. The context is implied by the verb, but there are no exclusions or conditions.

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 disclosing behavior. It indicates a mutation ('move') but does not mention prerequisites (e.g., the post must already be scheduled), whether the old schedule is overwritten, if the operation is reversible, or what the response contains. This is too thin 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 one-sentence description is front-loaded and contains no wasted words. It efficiently states the essential operation and the relevant format hint.

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, no output schema, and many sibling tools in the same domain, this description is too sparse. It does not explain the effect on existing schedules, differences from update_post, or expected return values, leaving an agent without the context needed 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?

Schema description coverage is 50%: scheduledAt is described, postId is not. The description adds the phrase 'target time', which conceptually links postId and scheduledAt, but it does not explain postId's meaning or add details beyond the schema's 'New ISO 8601 datetime'. It is adequate but not compensatory.

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 ('Move') and the resource ('a post's target time'), making it obvious that this tool changes a post's scheduled time. It is distinguishable from 'schedule_post' primarily by the name and the word 'move', though it does not explicitly say 'existing post' or 'replaces the current schedule'.

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

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

The description gives no guidance on when to use this tool instead of alternatives. Given siblings like schedule_post, update_post, and retry_post, an agent cannot tell whether reschedule_post is for altering an existing scheduled post or for replacing a failed schedule, and no exclusions or preferred contexts are 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 behavioral burden. 'Publish ... now' implies a mutation, but it does not disclose whether the retry is idempotent, what happens if the comment was already published, or whether it only works on comments in pending/failed state.

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 short sentence with no filler. It is front-loaded with the action and the target state, making it easy to scan and process.

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 one parameter, no annotations, and no output schema, the description is too thin. It conveys the basic action but omits behavioral expectations, return behavior, and any retry-specific semantics an agent would need 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?

Schema description coverage is 0%, and the description never mentions 'commentId' or explains how to identify the target comment. The phrase 'pending/failed comment' provides slight context, but the description does not compensate for the schema's complete 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 uses a specific verb ('Publish') and resource ('pending/failed comment') and clearly conveys that this tool retries an existing comment rather than creating a new one. This distinguishes it from siblings like create_comment and retry_post, though it does not name them explicitly.

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

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

The description implies the intended condition for use: a comment that is pending or failed and should now be published. However, it does not explicitly say when not to use this tool versus alternatives like update_comment or create_comment.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the core action (re-queueing failed schedules) and scopes it to failed schedules, which is useful. However, it does not disclose side effects, idempotency, failure behavior, or what happens when there are no failed schedules, leaving meaningful 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, tightly written sentence with no filler. The key action ('re-queue') and subject ('failed schedules') are front-loaded, and every word contributes to the meaning. It is concise without being under-specified in terms of 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 tool with one string parameter and no output schema, the description is adequate but not complete. It explains what the tool does but does not clarify what qualifies as a 'failed schedule,' any preconditions, or the outcome of the operation. The low parameter count reduces complexity, but the lack of parameter explanation and behavioral edge cases leave clear 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% and the description does not mention the 'postId' parameter at all. It only says 'a post's' without connecting that to the required parameter. The description provides zero additional meaning beyond the bare schema, so the agent receives no guidance on what postId should refer to or how it relates to the operation.

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 'Re-queue a post's failed schedules for another attempt' uses a specific verb ('re-queue'), names the exact resource ('a post's failed schedules'), and clarifies the purpose. It distinguishes itself from the sibling 'reschedule_post' by focusing specifically on failed schedules and retrying them, rather than rescheduling generally.

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 use case: when a post has failed schedules that need another attempt. However, it does not explicitly state when to use this tool vs. alternatives like 'reschedule_post' or 'schedule_post', nor does it mention any exclusions or prerequisites. The context is implied but not made 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 provided, the description must carry the full behavioral burden. It only states the action without disclosing side effects, idempotency, or whether it mutates state. For a re-run operation, this is insufficient – an agent cannot know if it will overwrite existing data or if it's safe to call repeatedly.

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

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

The description is a single, front-loaded sentence with no filler. It is concise and gets straight to the point, though it omits essential context. The efficiency is good, but the lack of detail makes it feel more like a stub than a well-structured description.

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, no output schema, and only one parameter, the description is too sparse. It doesn't explain the expected outcome, error handling, or any prerequisites. An agent would lack confidence in calling this tool correctly, especially given the ambiguity of 'failed rows'.

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 defines jobId as a string with no description, and the description doesn't explain it either. However, the term 'import job' implies jobId refers to the CSV import job identifier, which is somewhat inferable. Still, the description adds no explicit meaning beyond what the name suggests, so it barely meets the baseline.

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 action: re-running failed rows of an import job. The verb 're-run' and resource 'import job's failed rows' are precise, and the name retry_post_csv_import distinguishes it from retry_post and retry_comment, which target individual posts/comments. The intent 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?

No guidance is given on when to use this tool versus alternatives like retry_post or retry_comment. It doesn't mention prerequisites, conditions, or exclusions. An agent would have to infer that this is for CSV import jobs 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?

No annotations are provided, so the description carries the full burden. It signals a read-only 'lookup' behavior, which is helpful, but it does not disclose what the response contains, whether it performs external network calls, error behavior, or any side effects. For a tool named 'run_account_tool', the behavioral profile is underexplained.

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

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

The description is two sentences with no filler. The core action and the usage context are front-loaded, and the example input structures are compact and directly useful.

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

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

For a three-parameter tool with no output schema and no annotations, the description covers the key invocation scenario and gives input examples. However, it does not describe the return data, which matters because the agent needs a flair or board id from the response. It is adequate but not complete.

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

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

Schema coverage is only 33%, but the description compensates partly by showing valid tool values and their expected input shapes: reddit-flairs takes { subreddit } and pinterest-boards takes {}. The accountId parameter is only implied by 'per-account' and not formally explained, so the 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 states a specific action ('Run a per-account lookup') and identifies two concrete variants, reddit-flairs with an input and pinterest-boards with empty input. It is more specific than the tool's name, though it does not fully clarify whether these are examples or the exhaustive set, since the schema says the tool value comes from list_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 explicitly says when to use the tool: 'Use before creating posts that need a flair or board id.' This gives a clear precondition and purpose. It does not explicitly state when not to use it or name alternatives, but the connection to post creation is direct and useful.

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 discloses that this creates a scheduled post, but it does not mention validation, whether the time must be in the future, side effects, execution details, or what the response contains.

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 a useful example and no filler. It is concise and readable, though the terseness leaves behavioral and contextual details unaddressed.

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 write tool with 8 parameters, no annotations, and no output schema, this sparse description is not complete enough for an agent to invoke it confidently. It omits return value, scheduling constraints, and how related parameters like threadParts and accountOverrides interact.

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

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

Schema description coverage is 100%, so the schema already explains caption, mediaIds, postType, accountIds, scheduledAt, threadParts, firstComment, and accountOverrides. The description only adds a concrete example format for scheduledAt, which is a minor enrichment over the schema's existing ISO 8601 description.

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

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

The description clearly identifies the action ('Create') and the object ('a post'), and adds the scheduling qualifier with an ISO 8601 time example. It does not explicitly contrast schedule_post with siblings like create_post or reschedule_post, but the scheduling qualifier makes the core purpose unambiguous.

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

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

The phrase 'scheduled for an ISO 8601 time' implies this tool is for future-dated posts, which provides some usage context. However, it gives no explicit when-to-use guidance, no exclusions, and no alternatives such as create_post for immediate publishing or reschedule_post for changing an existing schedule.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals that only pending comments can be edited and that text/scheduledAt are independently updatable, but it omits permissions, error behavior for non-pending comments, side effects, and return values.

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

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

A single, front-loaded sentence with no filler. It conveys the action, target, and editable fields efficiently.

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

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

For a simple update tool with three parameters and no output schema, the description gives the core information needed. However, the lack of annotations, date format guidance, and any mention of constraints or failure cases leaves meaningful gaps for an agent to call it correctly in edge 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%, so the description must compensate. It usefully maps 'text' and 'due time' to the text and scheduledAt parameters and implies optionality via 'and/or', but it does not explain the scheduledAt format or clarify that commentId is the target identifier beyond the schema's required field.

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 ('Edit'), the resource ('pending comment'), and the editable fields ('text and/or due time'). This also distinguishes it from siblings like create_comment, delete_comment, and update_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 'pending comment' implies when to use this tool, but there is no explicit guidance about when not to use it or how it differs from alternatives like update_post or reschedule_post. The usage context is present but mostly inferred.

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 behavioral burden. It adds useful behavioral context, notably that setting scheduledAt to null clears the schedule and moves the post to draft. However, it does not disclose permissions, reversibility, status transition rules, or side effects on existing media or threads.

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 with no filler. It front-loads the core behavior ('Partially update a post') and packs the key fields plus the important scheduledAt-null behavior into a compact format.

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 12 parameters, no annotations, and no output schema, this description is not complete enough. It covers only a subset of parameters and lacks usage guidance and behavioral details needed to safely invoke an update operation with this complexity.

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

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

Schema description coverage is very low (8%), so the description must compensate. It adds meaning for caption, media, schedule, status, poll, and thread, but omits several non-obvious parameters like accountIds, delayMinutes, firstComment, and accountOverrides, leaving them undocumented.

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 and resource ('Partially update a post') and lists the updatable fields. However, it does not explicitly distinguish itself from the sibling reschedule_post, which also handles scheduling, so it is clear but not fully differentiated.

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

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

No guidance is given about when to use this tool versus alternatives like schedule_post, reschedule_post, or create_post. The description implies usage through 'partially update' but does not provide exclusions or conditions.

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

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

With no annotations, the description carries full burden for behavioral disclosure. 'Update' implies mutation but it doesn't state whether fields are partially updated or replaced wholesale, whether reassigning accounts overwrites the entire account set, or any permission requirements. The tool could have side effects (e.g., clearing fields if null) that 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 a single, concise sentence that front-loads the key actions (rename, re-describe, reassign accounts). It avoids verbosity, but the brevity comes at the cost of critical behavioral details. It's efficient, though not as structured as it could be with bullet points.

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

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

Given a mutation tool with 6 parameters, no output schema, and no annotations, the description is incomplete. It fails to cover all parameter semantics (slug, avatarUrl), doesn't specify the update semantics (partial vs. full replacement), and omits usage guidance. Compared to sibling tools like add_team_account, it doesn't clarify how to achieve specific account changes (replace vs. add).

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 all six parameters. It only names 'accounts' (accountIds) and implies 'name' and 'description' via 'rename/re-describe', but leaves 'slug' and 'avatarUrl' completely unaddressed. It also doesn't explain the semantics of optional fields, such as whether passing null clears a value.

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

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

The description clearly states the tool updates a team by renaming/re-describing or reassigning accounts, which is a specific verb+resource. However, it doesn't explicitly differentiate from sibling tools like create_team or delete_team, though the purpose is sufficiently clear on its own.

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 like add_team_account or remove_team_account for account reassignment. It also doesn't mention prerequisites like requiring an existing teamId or the effect of omitting optional fields (e.g., whether it clears them). No exclusions or conditional usage are given.

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

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

The description adds useful behavioral context by stating that the tool returns the media row whose id is referenced by posts via mediaIds. However, with no annotations provided, the description carries the full safety/behavior burden and does not disclose auth requirements, side effects, limitations, or error conditions.

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 focused sentences with no filler. The primary action is front-loaded, the source options are stated clearly, and the return value is given in the second sentence. Every line 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 core action, source inputs, and return value, which is helpful. But it lacks important invocation details such as whether one of url/path is required, mediaType expectations, or server-side constraints like size or accessibility. Given no annotations and no output schema, this is adequate but not 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 rephrases the url/path distinction already present in the schema and implies an 'or' relationship between the two source types, but does not explicitly state that one is required or clarify mediaType semantics. With 67% schema coverage, the description adds some value but does not fully compensate for the missing mediaType description.

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

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

The description states a specific verb and resource ('Upload media') and adds source modes ('public URL or local file path'), clearly distinguishing it from media siblings like list_media, get_media, and delete_media. An agent can immediately understand what this tool does and how it differs from related tools.

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

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

There is no explicit guidance on when to use this tool versus alternatives, nor any mention of prerequisites or exclusions. The description implies 'use this when you need to upload media' but does not route the agent away from other media tools or explain when not to use it.

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