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

Annotations (destructiveHint=false, openWorldHint=false) already indicate a safe, additive operation. The description adds the permission requirement but does not elaborate on error handling, idempotency, or any side effects beyond the basic add behavior.

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

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

The description is a single sentence plus a permission note - no wasted words. Every part is essential and front-loaded.

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

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

For a simple tool with 2 required parameters and no output schema, the description covers basic purpose and permission. However, it lacks details about error cases (e.g., invalid contactIds, non-existent list) and return value, leaving gaps for an agent to handle.

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% - no parameter descriptions. The description mentions 'by contactId' which clarifies the role of the contactIds parameter, but does not explain what constitutes a valid contactId or the expected semantics of listId beyond being a string identifier.

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 ('Add workspace contacts to a list'), the resource ('list'), and the input method ('by contactId'). It distinguishes itself from sibling tools like 'create_list' which creates a new list, not adds members.

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

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

The description includes an explicit permission requirement ('Requires lists:write'), offering context on when the tool can be used. However, it does not specify when to avoid using it or provide alternatives 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?

Annotations already set destructiveHint: true. The description adds that it 'start[s] building planned channels,' which explains the destructive nature. No contradictions with annotations.

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

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

Two sentences with no extraneous information: first states the action, second notes the permission requirement. Highly efficient.

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

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

While concise, the description lacks details on what 'a campaign strategy document' is or what 'planned channels' are. For a destructive action with no output schema, more context about outcomes would improve 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?

There is one parameter, 'creationId,' with 0% schema description coverage. The description does not explain what the creationId represents or how to obtain it, leaving the agent to infer from 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 clearly states 'Approve a campaign strategy document and start building planned channels,' which specifies a distinct action and resource. This differentiates it from sibling tools like 'read_marketing_strategy' or 'decide_approval'.

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

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

The description includes a prerequisite ('Requires `campaigns:write`') and implies when to use (approving a strategy). However, it does not explicitly contrast with alternatives like 'decide_approval' for other approvals.

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

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

Annotations already declare readOnlyHint=true, so the description's 'No workspace writes' is consistent but adds limited value beyond that. It does not disclose other behaviors such as authentication requirements, rate limits, or any side effects. The list of browsed items provides some contextual transparency.

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

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

The description is a single, front-loaded sentence that conveys all necessary information without extraneous words. Every part earns its place: the verb, the resource, the specific items, and the read-only note.

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

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

Given the tool's simplicity (no parameters, no output schema, low complexity), the description is largely complete. It states what is browsed (keys, variables, budget, etc.) and that it's read-only. However, it does not describe the return format or any default ordering, which would be helpful but not critical.

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

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

The tool has zero parameters and schema coverage is 100%, so the description is not required to explain parameters. Per guidelines, baseline for 0 params is 4. The description adds no parameter information because none is needed.

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

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

The description uses specific verbs 'Browse' and 'reserved transactional SMS keys' combined with a list of items (required variables, sample variables, message class, etc.), clearly identifying the resource and action. It distinguishes from sibling tools like list_sms_templates or browse_social_event_kit by specifying 'transactional SMS keys' and stating 'No workspace writes'.

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 viewing reserved transactional SMS kit details, but it does not explicitly state when to use this tool versus alternatives like list_sms_templates or send_transactional_sms. No when-not-to-use or alternative references are provided.

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

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

Annotations provide readOnlyHint=true, consistent with 'browse'. The description adds useful detail about returned data (keys, variables, channels, policy), enhancing transparency beyond annotations. No contradictions.

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

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

Extremely concise: two sentences, no filler. Purpose is immediately clear, and key output details are given without excess.

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

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

Given zero parameters and no output schema, the description adequately explains the tool's purpose and output. However, it could briefly clarify how this differs from browsing other social event catalogs.

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

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

No parameters exist, and schema coverage is 100% trivially. The description adds value by explaining what results to expect, which compensates for the lack of parameters.

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

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

The description clearly states the tool browses a platform-reserved event catalog and lists sample return values. However, it does not explicitly distinguish this tool from sibling tools like list_social_event_templates, which might also browse events.

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, such as list_social_event_templates or preview_social_event. The description only states what it does, not the context of use.

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

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

The destructiveHint annotation is reinforced by noting the run cannot be resumed. Also provides return format. No contradiction with annotations.

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

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

Two sentences with no fluff. Purpose and warning are front-loaded, making it easy to scan.

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

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

For a simple tool with one required parameter and no output schema, the description covers purpose, usage caution, and return value. Missing parameter details, but schema covers that.

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%, but the description does not explain the runId parameter beyond its name, failing to 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 clearly states the verb 'cancel' and resource 'active sequence run', distinguishing it from siblings like read_sequence_run or enroll_in_sequence.

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

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

Explicitly says 'Use sparingly — the run cannot be resumed', advising caution and indicating irreversibility, though no 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?

The description discloses that the tool persists by default and requires write permission, adding behavioral context beyond the annotations (which only indicate non-destructive and non-open-world). It does not contradict annotations. More detail on side effects (e.g., whether existing content is overwritten) would push this to 5.

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

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

The description is extremely concise (two sentences) with no wasted words. The first sentence captures the core purpose and a key behavioral detail, while the second adds the permission requirement. Ideal front-loading.

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 does not mention return values or error conditions, which would be helpful given the lack of an output schema. It covers the main action and a prerequisite but is not fully complete for an agent to anticipate all outcomes.

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 67% (two of three parameters have descriptions). The tool description adds no additional meaning beyond the schema's parameter descriptions, which already explain 'intake' briefly and 'persist' with its default. The 'idOrSlug' parameter remains undocumented. Since coverage is moderate, the description does not compensate further.

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 ('compose'), the resource ('landing-page block tree for an existing page'), and a key detail ('persists by default'). It distinguishes from sibling tools like 'read_page' (read) and 'publish_page' (publish) by explicitly using a different 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 mentions the required permission ('pages:write') and the default persistence behavior, providing some context for when to use. However, it does not explicitly state when not to use the tool or suggest alternatives, leaving usage boundaries implied rather than stated.

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

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

Adds value beyond annotations: hero image default behavior, credit charge, auth scope, return fields. No contradiction with annotations (destructiveHint false, openWorldHint false).

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

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

Three front-loaded sentences: purpose, side-effect, usage guidance. No fluff; 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?

Covers main workflow, return value, credits, auth. Missing: parameter explanations for most optional fields, error conditions. Adequate but not comprehensive for a 9-param tool without output schema.

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

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

Schema coverage is 11% (only prompt has description). Description clarifies includeHeroImage and prompt, but 7 of 9 parameters (key, mode, name, model, themeId, category, starterShellId) remain undocumented. Needs more parameter-level 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?

Clearly states verb ('Compose'), resource ('new email from a natural-language brief'), and distinguishes from sibling with 'Prefer this over create_template when the operator gave a brief.'

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

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

Explicitly says when to use (operator gave a brief), mentions credits and auth requirement. Could add when not to use, but the guidance is clear.

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

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

The description adds a permission requirement ('lists:write') beyond annotations, but does not disclose other behaviors like idempotency or error states.

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

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

The description is very concise (2 sentences) with the action front-loaded, but at the expense of missing parameter details.

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

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

For a creation tool with no output schema and 2 parameters, the description lacks details on return values, error conditions, and parameter 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?

With 0% schema description coverage, the description fails to explain parameters 'name' and 'description', leaving the agent without any additional meaning.

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

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

The description clearly states the verb 'Create' and resource 'contact list', distinguishing it from sibling tools like 'list_lists' and 'add_list_members'.

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; it only mentions a permission requirement, not usage context.

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

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

The description adds value beyond annotations by disclosing that the operation costs 1 credit and requires `links:write` permission. Annotations already indicate non-destructive behavior (destructiveHint: false) and open-world hint, but the description enriches the behavioral profile. It does not explain side effects or return value, but the cost and permission info are meaningful.

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 front-loads the core purpose and key constraints (cost, permission). It is efficient, but could benefit from a brief note on parameter roles without becoming verbose. Still, it earns a 4 for being concise and prioritized.

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

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

Given the tool has 4 parameters (including one required), no output schema, and a simple creation operation, the description is incomplete. It omits guidance on parameter values, return structure, or success/error behavior. The agent has insufficient context to use this tool correctly without external knowledge.

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 four parameters with zero documentation (0% schema description coverage), and the description provides no explanation for any of them. The description does not compensate for the lack of schema descriptions, leaving the agent without clarity on what `slug`, `label`, `campaignId`, or even `destinationUrl` represent or how to format them.

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

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

The description clearly states the tool creates a tracked short link, specifies it costs a credit, and requires a permission. This verb-resource combination is distinct from all sibling tools (no other link creation tool exists), achieving high specificity and 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 mentions the prerequisite permission (`links:write`), which is helpful context. However, it does not provide explicit guidance on when to use this tool versus alternatives or when not to use it. Since no alternative for creating short links exists in the sibling list, the lack of exclusions is acceptable but still suboptimal.

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

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

Annotations only set destructiveHint and openWorldHint false. The description adds behavioral details: creates content, consumes credits (social-post-compose, social-post-publish-url), requires specific permissions (social:posts:write, social:posts:publish), uses idempotency key. No contradiction with annotations.

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

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

Description is moderately long but efficiently packed with information. Front-loaded with main purpose and modes, then details on constraints, permissions, and special cases. Every sentence adds value, though could be slightly more structured with bullets.

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 16 parameters, no output schema, and complex behavior (modes, credit costs, platform rules, permissions), the description covers essential aspects. It explains mode choice, platform media requirements, permission scopes, and credit scenarios. Missing explicit return value description, but overall adequate.

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

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

Schema coverage is 63% (10/16 params have descriptions). The description adds meaning beyond schema: explains mode defaults ('copy' default), credit implications for X, and notes that channels come from list_social_networks. It provides context for idempotency-key via transport, which isn't in schema.

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

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

The description clearly states 'Create organic social post(s)' and distinguishes two modes (copy and compose). It differentiates from siblings like list_social_posts, read_social_post, etc., by focusing on creation and providing mode-specific guidance.

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

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

Provides explicit context on when to use each mode, platform constraints (Instagram/TikTok/YouTube/Pinterest need media, YouTube needs kind:video), credit costs for X links, and permission requirements. It advises preferring scheduleAt and confirming with operator before publish:true. No explicit alternatives for when not to use, but the guidance is clear.

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

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

Description discloses return fields (id, key, name, version) and auth requirement; annotations already set destructiveHint=false and openness. Minor gap: no mention of default values or side effects, but overall sufficient.

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

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

Three concise sentences: purpose, alternative recommendation, auth requirement. No wasted words.

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

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

Covers purpose, return values, usage guidance, and auth. Does not mention defaults or constraints, but given the schema and sibling context, it is fairly complete for an agent to use 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 only 29%, yet the description adds no explanation of parameters beyond their names. The parameters (e.g., mode, subject) are left in the schema without adequate descriptions, and the tool description does not compensate.

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 states 'Create a blank draft email template' with specific verb and resource, and distinguishes from sibling 'compose_template' by noting it is for when you have a brief.

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

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

Explicitly advises to prefer 'compose_template' when having a brief, and mentions the required scope 'templates:write', providing clear when-to-use and auth context.

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

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

The description adds important behavioral details beyond annotations: the secret is returned once and must not be logged, subsequent reads mask the secret. This aligns with openWorldHint=true and destructiveHint=false, with no contradiction.

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

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

Three sentences: purpose, usage, and security warning. Front-loaded and concise, every sentence adds value.

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

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

No output schema, but the description explains the return includes the secret and masks on subsequent reads. Covers events behavior and URL scheme validation. Could mention idempotency or limits, but adequate for 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 coverage is 67% (2 of 3 parameters described). The description reiterates URL and events behavior (omit for all events) but does not mention the 'description' parameter, leaving it undocumented. Baseline 3 is appropriate.

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

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

The description clearly states 'Create a new webhook subscription,' specifying the verb 'create' and resource 'webhook subscription.' Among siblings (list_webhooks), it distinguishes by describing the creation action and key parameters like URL and events.

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

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

The description explains when to use this tool by specifying required URL and events array, and notes that omitting events subscribes to all. It does not explicitly mention when not to use or provide alternatives, but the context is clear.

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

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

The description adds context beyond the destructiveHint annotation by enumerating the three possible decisions (approve, changes_requested, reject) and stating the required authentication. However, it does not disclose potential side effects (e.g., triggering workflows) or reversibility.

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

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

The description is two sentences, front-loaded with the core action, and contains no redundant information. Every sentence adds value.

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

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

Given the absence of an output schema and the need for action outcome feedback (success/error), the description lacks return value documentation. It also omits any post-action effects, making it incomplete for an agent to fully understand the tool's 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 0%, so the description must compensate. It clarifies that 'actingAsMemberUid' must be an assignee or admin and implicitly connects the enum values to the decision parameter. It does not explain 'comment' or 'requestId' semantics, leaving gaps.

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

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

The description clearly states the tool's purpose: 'Approve / request changes / reject a pending approval.' This specific verb-resource combination distinguishes it from sibling tools like 'manage_approval_policy' or 'list_pending_approvals'.

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

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

The description specifies when to use the tool by noting required actor (workspace member with assignee/admin role) and required scope ('approvals:write'). It does not explicitly state when not to use it or provide alternatives, but the context is clear.

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

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

DestructiveHint annotation already indicates destruction; description adds that deleting a live post requires fromProvider:true and specific permissions. No contradiction.

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

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

Two sentences, no extraneous information. Front-loaded with the main action and special parameter usage.

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?

Adequately covers the tool's purpose, parameters, and permission for a mutation tool with two parameters. Missing output description, but acceptable given no output schema.

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

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

Schema has 0% description coverage. Description explains fromProvider's effect but does not clarify postId (e.g., it's the ID of the post to delete). Adds some 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?

Explicitly states 'Delete a draft/ready/scheduled organic post' and distinguishes between deleting a draft and removing a live post via the fromProvider parameter. Clearly identifies the resource and 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?

Explains when to use fromProvider:true to delete a live post and mentions required permission. Does not explicitly state when not to use, but the sibling list suggests no alternative deletion tool, so usage is clear.

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

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

The description explains the enrollments array in the response, including the empty case. However, it does not disclose idempotency, side effects, or permission requirements. Annotations indicate non-destructive, but the description adds some value beyond them.

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

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

Two sentences, to the point, no unnecessary information. Could be slightly improved by front-loading the core action, but overall efficient.

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

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

Given 5 parameters, low schema coverage, and no output schema, the description is incomplete. It omits parameter semantics and usage constraints, making it insufficient for an agent to use correctly without additional knowledge.

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%, and the description does not add meaning for email, userId, or traits parameters. It only mentions the name parameter implicitly. No additional guidance on parameter usage or relationships.

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

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

Description clearly states the tool emits a customer event and explains the auto-enrollment behavior when sequences match. However, it does not explicitly distinguish from sibling tools like trigger_social_event or enroll_in_sequence, leaving some ambiguity.

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

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

Provides context on when sequences will auto-enroll, but no explicit guidance on when to use this tool versus alternatives. No mention of prerequisites or exclusions.

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

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

Annotations are minimal (destructiveHint: false, openWorldHint: false). The description adds value by disclosing idempotent behavior with a key and return values (run id, subjectId). It does not contradict annotations.

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

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

Two sentences with no wasted words. The action is front-loaded, and the most important behavioral detail (idempotency) follows directly. Every sentence adds value.

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

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

The description covers the main action, idempotency, and return values. However, with 4 parameters, a nested object, and no output schema, it lacks explanations for parameters like 'variables' and 'startAtStep', reducing completeness for an agent to correctly invoke 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 explanation of parameters beyond implying 'contact' is the contact to enroll. Terms like 'variables', 'startAtStep', and 'idempotencyKey' (mentioned but not in schema) are not clarified, leaving agents to infer from names and schema structure.

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 ('Enroll a contact directly into a published sequence'), using specific verbs and resources. It does not explicitly distinguish from siblings like 'cancel_sequence_run' or 'read_sequence', but the purpose is unambiguous.

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

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

The description provides usage guidance by highlighting idempotency for webhook retries, which helps when to use the tool. However, it does not mention when not to use it or alternatives among the sibling tools.

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

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

Adds valuable context beyond readOnlyHint: caching, refresh polling, null return, permission requirement. No contradiction with annotations.

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

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

Three concise sentences, front-loaded with purpose. Every sentence provides useful information without redundancy.

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

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

With no output schema, description explains return value (engagement metrics) and special case (null). Missing details on metric fields but sufficient for selection and 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?

Description explains refresh parameter and its effect, but postId is not described. Schema coverage is 50%; description partially compensates but leaves gap for required 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?

Clearly states 'Read engagement metrics for a published organic post.' Verb and resource are specific. Distinct from siblings like read_social_post.

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

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

Explicitly describes default caching behavior and how to refresh. Mentions permission requirement. Does not compare to alternatives but gives clear context for 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?

Annotations already mark it as read-only (`readOnlyHint: true`). Description adds the concrete permission requirement (`approvals:read`), which provides extra behavioral context beyond annotations. No contradictions found.

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

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

Two sentences, no fluff. Every word carries information: action, resource, grouping dimension, and precondition. Ideal for quick understanding.

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 simple tool with no input parameters and no output schema, the description sufficiently covers what the tool does and its prerequisite. Could be more complete by mentioning that no filtering is available (since no params), but not essential.

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

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

Input schema has zero parameters and 100% coverage, so description's job is light. It adds meaning by explaining the output nature ('by surface'), which clarifies the scope of listed policies. No parameter details are needed since none 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?

Description clearly states verb (list) and resource (approval policies), specifying that listings are grouped by surface (campaign, social_post, page, etc.). This uniquely identifies its function among siblings like list_pending_approvals and manage_approval_policy.

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?

Mentions required permission (`approvals:read`), which is useful, but does not provide explicit guidance on when to use this tool versus alternatives (e.g., list_pending_approvals for pending items, manage_approval_policy for modifications). Usage context is implied but not elaborated.

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

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

Annotations already declare readOnlyHint=true, and the description adds permission requirement ('Requires `campaigns:read`') and the polling behavior, which are beyond the annotations. No contradictions observed.

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

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

Three sentences, each serving a purpose: listing intent, usage, and requirement. No waste, front-loaded with purpose.

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

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

For a simple read-only list tool with two optional parameters and no output schema, the description covers purpose, usage, and permission. It could mention pagination or default limit, but overall adequate.

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

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

Schema coverage is 50% (only 'status' has a description). The description does not provide additional meaning for the 'limit' parameter, which lacks schema description. The 'status' parameter is already described in schema. The description adds marginal 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?

Description clearly states it lists campaigns/creations with strategy status and artefact summary, and specifies the use case of polling build progress. This differentiates it from many sibling list tools that list other entities (templates, sequences, etc.).

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

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

Description provides a specific use case ('Use to poll build progress.') but does not explicitly state when not to use this tool or mention alternatives among the many sibling list tools. The usage context is clear but lacks exclusions.

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

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

Annotations already provide readOnlyHint=true. Description adds ordering behavior ('Primary/active profiles first'), but no further behavioral details beyond what annotations convey.

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

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

Two sentences, front-loaded with purpose and ordering, followed by usage context and permission. No wasted words.

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

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

Covers purpose, ordering, usage context, and required permission. Missing explanation of 'detail' parameter, but overall adequate for a simple list tool with rich annotations.

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

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

Schema has one parameter 'detail' with enum, but description does not explain it. Schema coverage is 0%, yet description adds no value for parameter semantics beyond enum names.

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

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

Clearly states the verb 'List', resource 'ICPs', and provides sorting order 'Primary/active profiles first'. Distinct from sibling 'read_icp'.

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?

'Use before targeting campaigns' gives clear contextual guidance, and 'Requires marketing:read' specifies permission. No explicit exclusions or alternatives, but sufficient for simple use.

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

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

Annotations already declare readOnlyHint=true. The description adds value by specifying the required permission (`lists:read`) and the fields returned (name, contact counts), providing actionable behavioral context beyond what annotations offer.

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, minimal verbosity. The key information (action, result, permission) is front-loaded. Every word earns its place.

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

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

For a simple read-only list operation with no parameters and no output schema, the description fully covers the needed context: what it lists, what data is returned, and what permission is required. No 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?

No parameters exist, so schema coverage is 100%. Per rules, 0 params yields baseline 4. The description does not need to add parameter details, and it doesn't, but this is acceptable.

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

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

The description clearly states the verb 'list' and the resource 'contact lists', with a parenthetical indicating the returned fields (name, contact counts). This uniquely identifies its function among siblings, as there is no other tool for listing lists.

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 (e.g., read_list for a single list). Only the required permission is mentioned, which is helpful but insufficient for usage context.

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

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

The description declares read-only behavior and discloses that blueprints are excluded and what fields are returned. Annotations already provide readOnlyHint=true, so the description adds contextual details beyond annotations without contradiction.

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

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

Three sentences: first defines action, second details return values, third gives usage context and scope. Every sentence is informative and no waste.

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?

Despite having no output schema and no parameters, the description completely covers what the tool does, what it returns, its read-only nature, exclusions, and required scope. All necessary information for an agent to use the tool is present.

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

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

The input schema has zero parameters, so description coverage is 100%. The description does not need to explain parameters as none exist. 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 clearly states it lists workspace landing pages, specifies returned fields (id, slug, status, title, description, timestamps), and distinguishes itself by noting blueprints are excluded. It uses specific verb+resource and provides enough detail to differentiate from sibling tools like read_page.

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 'Use this to discover pages before reading one,' which provides clear guidance on when to use. It also mentions the required scope (`pages:read`). While it doesn't explicitly state when not to use, the context implies that it's a preliminary step before read_page, and alternatives are implicit through sibling names.

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

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

Annotations already declare readOnlyHint=true. Description adds auth scope context and clarifies status ('awaiting a decide'), but no additional behavioral traits beyond what annotations imply.

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

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

Two concise sentences, front-loaded with purpose, no extraneous text. 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?

Adequate for a simple list tool with no required params and one optional param. However, lacks mention of output format or pagination behavior, which would be helpful given no output schema.

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

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

Only parameter 'limit' has no description in schema or tool description. With 0% schema coverage, the description fails to explain its purpose, leaving the agent uninformed about pagination or 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?

Clearly states verb 'list', resource 'pending approval requests', and condition 'awaiting a decide'. Differentiates from siblings like 'decide_approval'.

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

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

Mentions required scope 'approvals:read' but no explicit guidance on when to use vs alternatives or when not to use. Adequate but minimal.

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

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

Discloses ordering, optional single-equality filter, ISO window, and return format with pagination cursor. Annotations confirm read-only, no contradictions.

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

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

Single sentence efficiently conveys purpose, filters, ordering, and return format without redundancy.

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

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

Covers all essential aspects for a list operation: resource, scope, ordering, filter constraints, pagination shape. No output schema needed given return structure in description.

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?

Adds meaning by grouping equality filters and describing 'since/until' as ISO window. Schema covers 63% of parameters; description compensates for non-schema parameters.

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

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

Clear verb 'List' targeting 'recent transactional sends' with explicit ordering 'createdAt desc'. Distinguishes from siblings like 'read_send' (single send) and others.

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

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

States optional filters and ordering, implying when to use (listing sends). Lacks explicit when-not-to-use or alternatives, but context from siblings is clear.

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

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

Annotations already declare readOnlyHint=true. The description adds that it returns key, name, trigger type, and enrolled count, which is useful. It does not mention pagination, ordering, or behavior with zero results, but for a simple list with no parameters, it is adequate.

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

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

The description is concise: two sentences with no wasted words. The first sentence states the action and aliases; the second lists return fields. It is front-loaded and efficient.

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

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

Given no output schema, the description adequately covers the return values (key, name, trigger type, enrolled count). It is complete for a simple list operation, though it could mention if only active sequences are included or ordering.

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

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

The tool has zero parameters, so the description does not need to explain parameter semantics. The baseline for 0 parameters is 4, and the description adds value by clarifying the output, which compensates for the lack of an output 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 the specific verb 'List' with the resource 'published sequences' and provides aliases ('flows / journeys / drip campaigns'). It clearly distinguishes from sibling tools like read_sequence (single sequence) and cancel_sequence_run (cancellation).

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 (listing published sequences in the workspace) but does not explicitly state when to use vs. alternatives like read_sequence or list_sends. It lacks explicit when-not or alternative 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?

Annotations already declare readOnlyHint=true. Description adds value by specifying the exact fields returned (status, segments, credits, etc.) and purpose (debugging), which informs agent of safe read behavior.

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

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

Two concise sentences, front-loaded with purpose and context. Every sentence adds value with no fluff.

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

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

No output schema, so description should explain return data for unfiltered case. Only describes filtered return fields. Missing details on pagination, ordering, and default fields for unfiltered query.

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

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

Schema coverage is 50% (only limit has description). Description explains templateKey usage: filtering and returning specific fields. This compensates for the undocumented parameter, adding meaning beyond schema.

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

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

Clear verb (read) and resource (recent transactional SMS delivery rows) with specific context (for debugging). Distinguishes from siblings like list_sms_templates and send_transactional_sms.

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

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

Provides clear context (debugging) and explains that optional templateKey filter returns specific fields. No explicit exclusions or comparisons to sibling tools, but context is adequate.

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

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

Annotations already declare readOnlyHint=true, and the description confirms a read-only listing operation. It adds value by detailing the specific fields returned (e.g., consent policy, last-sent timestamp) beyond what annotations provide.

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

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

The description is a single sentence (24 words) that is front-loaded with the action and resource. Every word adds value, 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?

With no output schema, the description adequately lists the returned fields for this list tool. It could be slightly more precise about the 'segment estimate' or 'consent policy' fields, but overall it provides sufficient context for an agent.

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

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

The input schema has 0 parameters with 100% coverage. The description does not need to add parameter details, and it does not mislead. Baseline score of 4 for zero-parameter tools is appropriate.

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

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

The description clearly states the tool lists the workspace transactional SMS kit and enumerates the returned fields (installed status, body template, variables, etc.). It is specific and distinguishes from sibling tools like list_templates or preview_sms_template.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as browse_sms_transactional_kit or list_templates. Given the large number of sibling tools, explicit usage context is missing.

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

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

Annotations already provide readOnlyHint=true, so the description's statement 'Read' is consistent. The description adds minimal behavioral context beyond annotations, such as the purpose of debugging and optional filtering. No additional traits like rate limits or authentication needs are disclosed.

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

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

The description is two sentences long, front-loading the core purpose and optional filter, then specifying the usage context. Every sentence adds value with no redundancy.

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

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

For a simple read-only tool with two optional parameters and no output schema, the description provides adequate context: purpose, usage scenario, and optional filter. It could be improved by hinting at the output fields, but the current level is sufficient for the complexity.

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

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

Schema coverage is 50% (only limit has a description). The description adds meaning for eventKey by stating it is an optional filter, but does not provide format or source details. The limit parameter description is already handled in the schema. The description partially compensates for the missing 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?

The description clearly states the verb 'Read', the resource 'Transactional Socials event runs', and the purpose 'for debugging'. It distinguishes from sibling tools by focusing on event runs rather than social posts or triggers, and includes a specific use case: when a developer asks why an emitted public social event did or did not post.

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

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

The description explicitly states when to use this tool ('Use when a developer asks why an emitted public social event did or did not post'), providing clear context. It does not explicitly mention when not to use or alternatives, but the context is sufficiently narrow.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, indicating safe read-only operation. Description adds that it returns publish policies and channel enablement, providing useful behavioral context beyond annotations.

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

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

Two sentences, no wasted words. Core information is front-loaded: verb and resource first, then usage guidance. Every sentence adds value.

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

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

No output schema exists, but description implies output includes templates, publish policies, and per-event-key channel status. For a simple list tool with no params, this is sufficient to understand what the tool returns.

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

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

No parameters exist; schema coverage is 100%. Description adds no redundant parameter info, which is appropriate. Baseline 4 for zero-parameter tools.

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

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

Description clearly states 'List the workspace-installed Transactional Socials templates and publish policies', specifying the verb 'list', the resource 'templates and publish policies', and the scope 'workspace-installed Transactional Socials'. This distinguishes it from siblings like 'list_templates' (generic) and 'list_sms_templates'.

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?

Description provides explicit when-to-use: 'Use this before previewing or triggering to see which channels are enabled for each event key.' While it doesn't explicitly mention when not to use or alternatives, the guidance is clear for the intended use case.

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 include readOnlyHint=true. Description adds that only company accounts are returned (no personal profiles) and lists the required permission 'social:posts:read'. This provides useful behavioral context beyond annotations, though no contradictions.

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

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

Two sentences cover purpose, scope, prerequisite usage, and permissions. No redundancy, front-loaded with the core action, every sentence earns its place.

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

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

Given zero parameters and readOnlyHint annotation, the description fully covers: what is returned (company accounts, not personal), required permission, and how to use the output for create_social_post. No output schema exists, but the description sufficiently informs the agent.

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

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

Input schema has zero parameters, so baseline is 4 per rules. Description adds value by mentioning the output fields (channelId, accountRef) and their usage, even without an output schema.

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

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

The description clearly states the verb 'List', the resource 'connected company / workspace social networks', and specifies examples (LinkedIn, Instagram, X). It distinguishes from personal profiles, and notes it should be called before create_social_post, providing clear differentiation from sibling tools like list_social_posts.

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

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

Provides explicit guidance: 'Call this before create_social_post and only use channelId / accountRef values from the response.' It also states required permissions. While it doesn't list when not to use it, the context is clear for a straightforward list tool.

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

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

Annotations already declare readOnlyHint=true. The description adds permission requirements (social:posts:read) and filter details but does not disclose potential pagination behavior, rate limits, or sorting. Additional context is useful but not extensive.

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

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

Two sentences, front-loaded with purpose, followed by filters and permission. Every sentence is meaningful and concise with no wasted words.

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

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

No output schema is provided, and the description does not mention return values, response structure, or default behavior (e.g., sorting, pagination). For a simple list tool, the description is adequate but could be more informative, especially regarding output.

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% (3/6 parameters described). The description clarifies that all parameters are optional filters, specifies ISO timestamps for from/to, and limit range (1-100). This adds moderate value but does not fully compensate for the undocumented parameters (status, groupId, channelId).

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

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

The description clearly states the tool's purpose: 'List organic social posts in the workspace.' It specifies the resource (organic social posts) and scope (workspace), distinguishing it from sibling tools like list_social_event_runs or list_templates.

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 lists optional filters and permission requirements, but does not provide explicit guidance on when to use this tool vs. alternatives like read_social_post or list_social_event_runs. Usage context is implied but no exclusions 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?

Annotations declare readOnlyHint=true, and the description details the returned fields, adding clarity. No destructive behavior or auth needs are disclosed, but given the read-only nature and simplicity, it is adequately transparent.

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

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

The description is two sentences, front-loading the purpose and return fields, followed by usage guidance. Every sentence adds value with no wasted words.

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

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

Given no output schema, the description adequately explains the return fields. Combined with purpose and usage guidance, it fully equips an agent to select and invoke 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 tool has no parameters, so the schema provides complete coverage. The description does not need to add param semantics, earning a baseline score of 4.

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

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

The description clearly states the tool lists email templates in the workspace and specifies the returned fields (id, key, name, etc.), distinguishing it from sibling tools like read_template or create_template.

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 advises using this tool to discover available templates before reading or sending, providing clear context. It does not explicitly mention when not to use it or alternatives, but the guidance is sufficient for a list tool.

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

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

Annotations already mark readOnlyHint=true. The description adds valuable behavioral details: each entry includes URL, events, delivery health, and that secrets are masked. This goes beyond the annotation.

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

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

Three sentences, no wasted words. The main purpose is front-loaded in the first sentence.

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

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

For a simple list tool with no output schema, the description fully explains what the output contains (URL, events, health) and a security note about secrets. No 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?

No parameters exist, so schema coverage is 100%. The description adds no parameter info, but baseline for 0 params is 4. It implicitly references workspace 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 clearly states the verb 'list' and the resource 'webhook subscriptions for the workspace'. It is specific and distinguishes from other tools like create_webhook.

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 or when not to use it. The description only explains what the tool does, not its context of use.

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

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

Annotations already declare destructiveHint=true, and the description says 'Upsert', which implies modification. The description adds the permission requirement, which is useful. However, it does not disclose potential side effects (e.g., what happens to existing policies) or error conditions beyond the permission. Annotations bear most of the burden here.

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

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

The description is very concise: one sentence plus a permission note. It is front-loaded with the core action. However, it sacrifices parameter details, which could be added without making it verbose. Still, it earns a 4 for efficiency.

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

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

Given the complexity (5 parameters, 2 required, destructive behavior, no output schema), the description is incomplete. It does not explain return values or behavior upon success/failure. The parameter semantics gap leaves the agent underinformed. Sibling tools are numerous, but the description does not help differentiate beyond the basic purpose.

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

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

Schema description coverage is 0%, so the description must explain parameters. It only mentions 'surface' broadly but does not define any of the 5 parameters (mode, poolRule, onApproval, surfaceKind, approverMemberIds). The enums are not explained, leaving the agent guessing about valid values and their effects.

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 upserts an approval policy for various surfaces like campaign, page, social_post. This directly explains the action and resource, and distinguishes from sibling tools like list_approval_policies (read-only) and decide_approval (different action).

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

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

The description mentions the required permission 'approvals:write', which is helpful context. However, it does not explicitly guide when to use this tool versus alternatives (e.g., list_approval_policies to view policies, or other creation tools). Usage is implied but not clearly 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?

Annotations provide destructiveHint=true, and the description adds that the operation is a 'sparse merge,' clarifying it is a partial update. This goes beyond annotations but does not detail other behavioral aspects like idempotency.

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 remarkably concise: two sentences that front-load the key information (action, resource, behavior, permission). 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 mutation tool with one parameter and no output schema, the description covers the essential aspects: operation type, merge behavior, and required permission. It could mention what the tool returns, but given no output schema, the description is reasonably complete.

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

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

Schema coverage is 100% with a clear description of the 'patch' parameter. The tool description reinforces that it is a sparse merge but does not add significant new 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?

Title and description clearly state the tool patches the live marketing strategy with a sparse merge. It is distinguished from its sibling read_marketing_strategy, which is a read-only counterpart.

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 only usage guideline is the permission requirement (`marketing:write`). No explicit when-to-use or when-not-to-use information is provided, nor are alternatives mentioned.

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

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

Annotations declare readOnlyHint=true, and description does not contradict. Description adds transparency by specifying return values (plain-text body, missing variables, segment estimate) and that it does not send. No mention of errors or limitations, but sufficient for read-only.

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

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

Extremely concise: one main sentence plus a clarifying sentence. No wasted words, front-loaded with 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 read-only preview tool with 3 params and no output schema, the description covers key return values and behavior. Could mention error cases or prerequisites, but adequate for typical use.

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

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

Schema coverage is 67% (variables and bodyTemplate have descriptions). Tool description does not add new meaning beyond schema for these params, and templateKey is not further explained. Baseline 3 is appropriate as schema handles most semantics.

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

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

Description clearly specifies the action (render, return body, missing variables, segment estimate) and explicitly states it does not send. Distinguishes from sending tools like send_transactional_sms.

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?

Description states what the tool does and that it doesn't send, but lacks explicit guidance on when to use over siblings like render_template or compose_template. Could add context like 'Use to preview before sending'.

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 declare readOnlyHint=true, which the description corroborates by stating 'without posting' and 'no draft'. Description adds value by detailing return values (per-channel captions, warnings, missing variables), going beyond the structured annotations.

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

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

Two sentences, front-loaded with core purpose, no fluff. Every sentence adds value: what it does, what it returns, what it doesn't do.

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 preview tool with no output schema, the description adequately explains return values and limitations (no draft). Could optionally clarify variable requirements or channel format, but sufficient for typical use.

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

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

Schema description coverage is 100% (all three parameters have descriptions). The description does not add significant new meaning beyond the schema, but remains consistent. Per the rubric, baseline 3 applies due to high coverage.

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

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

Description explicitly states the tool renders a social event preview without posting, and specifies return values (captions, warnings, missing variables). It clearly distinguishes from posting tools like trigger_social_event or publish_social_post.

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

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

The description clearly states the purpose (preview without posting, no draft created), implying use before posting. However, it does not explicitly mention when not to use or name alternative tools, though sibling names provide context.

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

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

Annotations provide destructiveHint=false, so the description does not contradict. It adds that the tool returns a change-request id and status, but does not explain side effects (e.g., whether it immediately modifies the template or requires approval). This is adequate but lacks richer context.

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

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

The description is two sentences, front-loading the purpose and return value, followed by a concise usage condition. Every sentence adds value with no redundancy.

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

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

Given no output schema and minimal annotations, the description lacks details about the change approval process, whether the tool is synchronous, or what the returned 'current status' indicates. It covers basic use but leaves uncertainty about behavior and outcomes.

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%. The description does not explain any of the 5 parameters (notes, effect, variable, templateKey, fromVariable) beyond the tool's name. For example, the effect enum is only 'add', but variable and fromVariable are detailed objects with no explanation. The agent must rely solely on the schema, which is insufficient.

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 'request a variable change' and the resource 'template's schema'. It also mentions the return of 'a change-request id and current status'. The usage phrase 'when your code needs a variable the template doesn't yet expose' distinguishes it from sibling template tools like render_template or create_template.

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

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

The description provides a clear condition for use: 'Use when your code needs a variable the template doesn't yet expose.' It does not explicitly state when not to use or mention alternatives, but the context is well-defined 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?

The description adds the permission requirement, which is not covered by the annotations' destructiveHint or openWorldHint. However, it does not elaborate on side effects or behavioral nuances beyond what annotations imply.

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

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

The description is extremely concise at two sentences, with no wasted words. The permission requirement 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?

The description is minimal and lacks information about return values, side effects (e.g., overwriting existing publications), or error conditions. For a destructive tool, more context would be beneficial.

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

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

With 50% schema description coverage, the description does not explain the parameters. It omits details for 'idOrSlug' and only repeats the 'slug' parameter's schema description without adding 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 verb 'publish' and the resource 'landing page', making the tool's function unambiguous. It is distinct from sibling tools like 'compose_page' or 'read_page'.

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

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

The description mentions the required permission ('Requires `pages:publish`') but gives no guidance on when to use this tool versus alternatives. It does not specify prerequisites or scenarios.

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?

Adds value beyond destructiveHint annotation by disclosing permission requirement ('social:posts:publish') and credit cost, though does not mention reversibility or failure behavior.

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

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

Three concise sentences with front-loaded purpose, no wasted words.

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

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

Covers key aspects (purpose, usage condition, cost, permission) though lacks output description; acceptable given no output schema.

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

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

Schema coverage is 50% (only targetAccountRef has a description); the description adds no parameter-level meaning for postId or additional context beyond what schema provides.

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

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

The description clearly states the verb 'Publish' and the resource 'an organic post now to the company network', distinguishing it from siblings like create_social_post (draft creation) and schedule_social_post (scheduled publish).

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

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

Provides explicit operator confirmation requirement and cost/credit rule, but does not list alternatives or 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?

Annotations already provide readOnlyHint=true, and the description confirms 'Read-only' and adds the required scope (brand:read), which is useful context beyond annotations. No side effects or destructive behavior are noted, but the description is transparent.

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

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

The description is three sentences, front-loaded with the action and resource, and every sentence adds value. It is concise and well-structured without unnecessary information.

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

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

Given no output schema, the description explains the return values (brand attributes). Complexity is low (0 parameters), and the description is complete enough for an agent to understand what the tool retrieves. Slight improvement could be a more detailed format, but not necessary.

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 no parameters, and schema coverage is 100%, so the baseline is 3 per instructions. The description lists output fields but does not add parameter-specific meaning, which is appropriate given no parameters.

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

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

The description clearly states the tool reads the workspace's default brand and lists specific components (name, voice/tone, colour palette, fonts, logos, imagery doctrine). It distinguishes from sibling tools like read_workspace by being brand-specific.

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 'Use this BEFORE drafting any copy or proposing a template' providing clear usage context. However, it does not explicitly state when not to use it or mention alternatives, which would elevate the score.

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

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

Annotations already declare readOnlyHint=true. The description adds value by specifying the required permission (campaigns:read) and explaining the behavior of the detail parameter for raw CampaignDoc retrieval.

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 with three clear statements: purpose, parameter behavior, and permission. No redundant or irrelevant information.

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

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

For a simple read operation with annotations, the description covers purpose, key parameter behavior, and permissions. Lack of explicit output structure is mitigated by listing returned fields, but could be more complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the effect of the detail parameter but does not explicitly describe creationId. While creationId is implied, the description adds partial clarity.

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

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

The description clearly states the tool reads a creation/campaign by ID and lists the specific data returned (strategy status, artefacts, brief). It uses a specific verb-resource combination, distinguishing it from sibling tools like list_creations or read_workspace.

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

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

No explicit guidance on when to use this tool versus alternatives (e.g., list_creations). The permission requirement is mentioned but does not help with tool selection context.

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

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

The description adds behavioral details beyond the readOnlyHint and openWorldHint annotations, such as reading both stored values and the resolved factory-merged set. No contradictions with annotations.

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

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

The description is exceptionally concise with two sentences, front-loading the key purpose and listing fields, then adding the value type and permission. No unnecessary words.

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

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

Despite no output schema, the description sufficiently explains what is returned (the listed fields in both stored and resolved forms) and the required permission, making it complete for a parameterless read tool.

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

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

No parameters exist, so baseline score of 4 applies per guidelines.

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

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

The description clearly states the verb 'Read' and the resource 'workspace creation defaults'. It lists the specific fields, effectively distinguishing it from siblings like 'set_creation_defaults' and 'read_workspace'.

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 guides usage by specifying the exact data it reads and the required permission 'marketing:read'. It does not explicitly state when not to use but the context is clear.

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

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

The description aligns with the `readOnlyHint` annotation by stating 'Read', confirming non-destructive behavior. It adds the permission requirement, providing valuable behavioral context beyond annotations. No other traits like rate limits or side effects are mentioned, but for a read tool this is adequate.

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

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

The description is extremely concise with two sentences: the first states the purpose, the second gives the auth requirement. No unnecessary words or redundancy.

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

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

For a simple read-by-id tool with one parameter and no output schema, the description covers the key aspects: what it does and what permission is needed. It could mention what the response contains, but given the simplicity, this is 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?

The schema has 0% description coverage for the single parameter `icpId`, and the description only says 'by id', which adds little beyond the parameter name. For a simple identifier, this is minimally acceptable but fails to provide any format or example guidance.

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 ('Read') and the resource ('one Ideal Customer Profile by id'), distinguishing it from sibling tools like list_icps which retrieves multiple profiles. The verb and noun are specific and unambiguous.

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

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

The description explicitly notes the required permission (`marketing:read`), which guides when the tool can be used. While it doesn't explicitly state when not to use it or list alternatives, the purpose is clear enough given sibling context.

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

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

Annotations already indicate readOnlyHint=true, and the description adds the permission requirement (`lists:read`), providing useful context beyond annotations. No contradiction.

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

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

Two concise sentences that convey purpose and required permission without any unnecessary words.

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

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

Given the lack of output schema, the description could hint at what is returned (e.g., list details). As it stands, it is minimal but sufficient for a simple read operation with clear annotations.

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

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

With 0% schema description coverage, the description adds minimal value by stating 'by id', which clarifies the parameter's role but is still quite vague; does not specify format or constraints.

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 ('read') and resource ('one contact list by id'), distinguishing it from sibling tools like 'list_lists' which lists all lists.

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

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

The description mentions the required permission ('Requires `lists:read`') but does not provide explicit guidance on when to use versus alternatives (e.g., listing all lists).

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

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

Annotations already declare `readOnlyHint=true`, so the description adds value by specifying the required permission (`marketing:read`). It also implies the document is 'live', adding behavioral context beyond annotations.

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

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

Three sentences, each earning its place: first defines what it reads, second gives usage guidance, third specifies parameter usage and permission. No fluff, front-loaded with 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?

Given there is no output schema, description mentions contents but not format. It covers purpose, usage, parameter, and permission. For a simple read tool, it is fairly complete; could mention return format or error cases but not essential.

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

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

Schema coverage is 100% and already describes the parameter. The description adds the example 'Pass detail='full' for the entire doc', which is helpful but largely repeats the schema's enum descriptions. 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?

Description states specific verb 'Read' and resource 'Marketing Strategy', lists contents (positioning, vision/mission, etc.), and distinguishes from sibling tools like `patch_marketing_strategy` by focusing on reading. It provides clear guidance on when to use it (before drafting campaigns).

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?

Description explicitly says 'Call this BEFORE drafting campaigns or copy', giving clear context. It also mentions passing `detail='full'` for the entire doc. However, it does not provide when-not-to-use or compare with other read tools, though the purpose is clear enough.

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

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

Annotations already provide readOnlyHint=true. The description adds critical behavioral details: requires 'pages:read' scope, returns specific metadata fields and section summary, and explicitly warns that the full block tree is excluded due to context size limits, which is beyond the annotations.

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

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

The description is two sentences, front-loading the core action and resource, then providing essential details. Every sentence adds value with no redundancy.

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

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

Despite having no output schema, the description fully explains the return values (metadata fields, section summary) and what is omitted. This is complete for a simple read tool, given the context of annotations and sibling tools.

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

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

Schema coverage is 100% with a single parameter described as 'Page id or URL slug.' The description essentially repeats the schema description without adding semantic detail, so 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 uses the verb 'Read' and specifies the resource 'landing page' by id or slug. It clearly states what is returned (metadata and section summary) and contrasts with what is not returned (full block tree), distinguishing it from sibling tools like list_pages.

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

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

The description explicitly states what the tool returns and what it does not return ('not the full block tree, which is too large for model context'), implying when to use it (for metadata) and when not (for full page content). However, it does not explicitly name an alternative tool for the full block tree.

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 provide readOnlyHint=true, and the description adds that the tool returns SendPublic shape with fields like connectorProvider, metadata, and simulation when sandbox. This goes beyond annotations by detailing the return shape and special sandbox behavior.

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

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

Two sentences with zero fluff. First sentence states purpose and delivery events. Second sentence provides parameter source and return shape. Every word earns its place.

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

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

For a simple read tool with 1 parameter, no output schema, and annotations indicating read-only, the description fully covers: what it does, how to get the id, what it returns (with sandbox nuance). No 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 schema only defines id as a required string with no description (0% coverage). The description adds crucial semantic meaning: 'Pass the id returned by send_test or send_transactional.' This tells the agent what the id represents and its source, fully compensating for the schema gap.

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

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

The description clearly states the verb 'Inspect' and the resource 'send's current status and delivery events', specifying the exact delivery events list. It distinguishes from sibling tools by mentioning that the id comes from send_test or send_transactional, which are unique to sends.

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 tells the agent to pass the id returned by send_test or send_transactional, providing clear context for when to use this tool. It does not explicitly list exclusions or alternatives, but the context is strong.

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

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

Annotations already declare readOnlyHint=true. The description adds behavioral context about the return structure and notes the unavailability of the full graph, enhancing transparency without contradiction.

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

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

Two concise sentences, no wasted words, and the key information is front-loaded. Efficient and clear.

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

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

For a read tool with one parameter and no output schema, the description sufficiently explains what is returned (trigger config, status, counts) and notes the full graph exclusion, making it complete.

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

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

With 0% schema description coverage, the description compensates by clarifying that keyOrId can be a key or id, adding semantic meaning beyond the schema's type string.

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

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

The description clearly states the tool reads a sequence by key or id and specifies the return data (trigger config, status, graph counts). It differentiates from siblings like read_sequence_run.

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 guides usage by noting the full graph is too large for model context, indicating a limitation. However, it lacks explicit when-to-use versus alternatives.

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

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

Annotations already declare `readOnlyHint: true`, and the description states 'Read' which is consistent. The description does not add additional behavioral context beyond the annotations, such as rate limits or data freshness. No contradictions with annotations.

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

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

Description is two sentences long, no unnecessary words. It efficiently conveys the purpose, parameter source, and action. Perfectly concise and front-loaded.

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

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

For a simple read tool with one parameter and read-only annotations, the description is adequate. It lacks details on return values (no output schema), but the name implies the full object is returned. Given low complexity, this is sufficient.

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

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

Schema has 0% coverage (no descriptions for parameters), so the description compensates by explaining the runId parameter: it is returned by `enroll_in_sequence` and visible in webhook events. This adds meaningful context beyond the schema's raw type 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?

Description uses specific verb 'Read' and resource 'sequence run', clearly indicating the action. It also specifies that it retrieves the state, which is distinct from other operations like canceling or listing. However, it does not explicitly differentiate from sibling tools, though the name and description make the purpose 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?

Description provides practical guidance on how to obtain the run ID (from `enroll_in_sequence` or webhook events). However, it does not explain when to use this tool vs. alternatives like `list_sequences` or `cancel_sequence_run`. The usage context is implied but not explicit.

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

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

Annotations already declare readOnlyHint=true, indicating a safe read operation. The description adds that it returns specific fields and requires a permission, but does not disclose additional behavioral traits such as whether the post must belong to the user or if there are rate limits. The description is consistent with annotations; no contradiction.

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

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

The description is concise: one sentence plus a permission requirement. It efficiently conveys the core purpose and needed fields. However, it could be slightly more structured (e.g., separate lines for fields and permission). Overall, it is well-sized and front-loaded.

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

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

Given the tool's simplicity (one parameter, no output schema), the description provides a reasonable amount of context: it describes the returned fields (caption, media, schedule, status, publishedUrl) and the required permission. This helps the agent understand what to expect, though more detail on the postId parameter would improve 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?

The only parameter, postId, is a string but the description does not explain its meaning, format, or how to obtain it. With schema description coverage at 0%, the description carries the full burden, but it only says 'by id' without further clarification. This is insufficient for an agent to correctly construct the parameter 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 action (read), the resource (one organic social post), and the scope (by id). It also lists the fields returned, which helps the agent understand the tool's output. This distinguishes it from siblings like list_social_posts (which returns multiple) and get_social_post_analytics (which returns 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 mentions the required permission (social:posts:read), which provides context for when the tool can be used. However, it does not explicitly state when to use this tool versus alternatives like list_social_posts or get_social_post_analytics, nor does it mention any prerequisites or exclusions.

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

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

Annotations already declare readOnlyHint=true, so the description's addition of the return structure (body, subject, variables, schema-contract) adds valuable behavioral transparency beyond what annotations provide.

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

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

Two sentences with zero redundancy. Returns are listed concisely, and parameter guidance is front-loaded. Every word adds value.

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

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

For a simple read tool with readOnlyHint and a single parameter, the description fully covers what the tool does, what it returns, and how to use the parameter. No gaps remain.

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

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

Schema description coverage is 100%, and the description merely echoes the schema's 'key (preferred) or id' with no additional semantic detail. At high coverage, 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?

Description specifies 'Read a single template' and details exactly what is returned (body HTML, subject, declared variables, schema-contract block). It clearly distinguishes the tool's resource and scope from sibling tools like list_templates.

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 advises to 'Pass `key` (preferred) or template id,' providing clear usage guidance for the parameter. It implies this is for reading a single template, not for listing, but does not explicitly exclude alternatives.

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

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

Annotations already mark it as readOnlyHint=true. The description adds value by stating it is 'cheaper' (performance implication) and that it 'returns ONLY the variables + schema contract', providing additional behavioral context without contradicting annotations.

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

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

Two sentences, each serving a distinct purpose: the first states the core function and cost comparison, the second provides usage guidance. No unnecessary words; front-loaded with the key differentiator.

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

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

For a simple read-only tool with one parameter and no output schema, the description covers purpose, usage, and key differentiator. It mentions the return type ('variables + schema contract') which is somewhat vague but adequate. Slightly incomplete regarding output structure but sufficient.

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

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

The single parameter 'key' has no schema description, and the tool description does not explain what 'key' represents or its format (e.g., template ID or name). With 0% schema description coverage, the description fails to compensate, leaving the agent to infer the meaning.

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

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

The description clearly states the tool returns 'variables + schema contract' for a template, and distinguishes itself from the sibling tool 'read_template' by highlighting it is cheaper and returns only a subset, not the full HTML body.

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 'Use when you need to know what variables a template expects without pulling the full HTML body', providing a clear use case and implicitly excluding scenarios where the full template is needed, with 'read_template' 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?

The description aligns with the readOnlyHint annotation and adds detail about the exact data returned. It doesn't disclose additional traits like authentication, but given the read-only nature, this is sufficient.

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

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

The description is two sentences, front-loaded with the action, and every sentence provides essential information without fluff.

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

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

The description fully explains the return values and usage context. Despite no output schema, the description compensates adequately.

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

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

With no parameters, the baseline is 4. The description appropriately omits parameter details as none 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 explicitly states the tool resolves a bearer token to its home workspace, lists specific return fields (workspace id, name, plan tier, scopes), and distinguishes it as a session initialization tool. It uses specific verbs and resource, making its purpose unmistakable.

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

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

The description provides explicit guidance to use this at the start of a session to confirm the workspace. While it doesn't mention when not to use or alternatives, the context of being a read-only introspection tool makes usage clear.

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

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

Annotations already declare readOnlyHint=true. Description adds behavioral details about what is logged, which annotations do not cover. Does not disclose potential rate limits or pagination, but for a simple read tool this is adequate.

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

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

Two sentences: first defines purpose, second gives use case and parameter guidance. No redundancy, front-loaded, every sentence earns its place.

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

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

Simple tool with one parameter and no output schema. Description covers purpose and parameter. Could mention return format, but the examples of logged actions imply the shape. Complete enough for this complexity.

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

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

Schema coverage is 100% and schema describes limit well. Description adds context by mentioning default and max values and how to use it. Adds value beyond schema.

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

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

Clearly states it reads recent audit log entries and lists what is logged (API calls, schema changes, sends, member actions). Distinguishes from sibling tools which are all about creating, deleting, or managing resources.

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

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

Provides explicit usage context: 'Useful when an agent is asked why did that happen?'. Also gives guidance on limit parameter. Does not explicitly mention when not to use, but given no similar sibling tools, it's sufficient.

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

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

Discloses permission requirement (social:posts:publish (Glow+)) and return type (refreshed company-only network list). Annotations already include openWorldHint and destructiveHint=false, so description adds context on provider integration. Missing potential latency or failure modes, but adequate.

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

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

Two sentences, front-loaded with action and specifics ('Re-sync...'), no wasted words. Efficient and clear.

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

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

Covers purpose, usage timing, permission, result type. For a zero-parameter tool with annotations, this is fully sufficient.

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

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

No parameters; baseline 4 applies. Description adds no param details since none exist, but the absence is acceptable given schema coverage is 100%.

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 ('Re-sync connected company networks'), specifies the provider (Ayrshare + native X/LinkedIn merge), and distinguishes it from sibling tools like list_social_networks by emphasizing refresh behavior.

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

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

Explicitly says when to call: after connecting a new account or when list_social_networks appears stale. Provides alternatives implicitly by contrasting with listing.

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 annotation readOnlyHint=true already indicates no side effects. The description adds that it returns warnings for undeclared variables, which provides useful behavioral context beyond the annotation.

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

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

Three sentences, no redundancies, each sentence adds value: purpose, side-effect clarification, and return value 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?

The description explains what the tool returns (HTML, subject, warnings array) despite having no output schema. It provides enough context for the agent to understand usage and expectations.

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

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

Schema coverage is 50%: 'variables' has a description with an example, but 'key' lacks a description. The description does not add meaning for the parameters, leaving 'key' ambiguous. Baseline 3 is appropriate as the schema partially covers the parameters.

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

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

The description uses a specific verb ('Render') and resource ('template to HTML + subject'), clearly stating what the tool does. It distinguishes itself from siblings like 'send_transactional' by noting that no email is sent.

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

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

Explicitly states 'No email is sent. Useful for previewing the output before calling send_transactional.' This directly tells the agent when to use this tool (preview) and when to use an alternative (send).

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 context beyond annotations by explaining the scheduling mechanism ('uses the same provider path as the SPA (Ayrshare scheduleDate or native X/LinkedIn queues) — not a Firestore-only stamp') and noting the permission requirement. Annotations already indicate destructiveHint:true, and the description confirms this is a state-modifying operation.

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

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

The description is efficient at three sentences, front-loaded with the core purpose, followed by technical context and alternative guidance. No extraneous information.

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

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

For a scheduling tool with 3 parameters and no output schema, the description provides good usage context but lacks details on behavior such as conflict handling (e.g., overwriting an existing schedule) or idempotency. It is adequate but not fully comprehensive.

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 low (33%); only scheduledAt has a description ('ISO-8601'). The description does not add meaningful context for postId or targetAccountRef beyond the tool's purpose. It implies postId is the post to schedule but does not clarify the role of targetAccountRef.

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 'Schedule an existing organic post,' specifying the verb 'schedule' and the resource 'existing organic post.' It distinguishes from the sibling create_social_post by noting that the latter is for creating fresh posts with scheduleAt.

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 provides guidance on when to use this tool vs. alternatives: 'Prefer create_social_post with scheduleAt when creating fresh.' It also mentions the required permission 'social:posts:publish.'

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 value beyond annotations by clarifying the tool never charges credits and only sends to a test inbox, which mitigates the destructiveHint. It also specifies the required bearer token scope. No contradiction with annotations.

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

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

Three sentences, front-loaded with purpose, then safety guarantee, then auth and return. Every sentence adds essential information with no fluff.

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

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

Covers purpose, safety, required scope, and return value. Lacks details on 'variables' parameter, but for a test tool the description is reasonably complete given the 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 33% (only 'to' has description). The tool description does not explain the 'key' parameter (likely template key) or 'variables' parameter (likely template variables), leaving the agent guessing about their purpose.

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

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

The description clearly states 'Send a test of a template to a verified test inbox' with specific verb and resource, and distinguishes from sibling tools by emphasizing it's a test send that never charges credits or hits real recipients.

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

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

The description explains when to use ('validate output during development') and what not to do (never charges credits or hits real recipient). It also mentions the required OAuth scope, but does not explicitly name alternatives or when not to use.

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

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

Annotations already mark destructiveHint=true and openWorldHint=true. The description adds value by noting it 'Charges credits and surfaces in webhooks + analytics,' and emphasizes the confirmation requirement. No contradictions with annotations.

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

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

Three sentences efficiently cover purpose, behavioral side effects, and critical usage guideline. No redundant information; every sentence adds necessary 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?

Given the tool's complexity (8 params, nested objects, no output schema), the description is insufficient. It omits essential parameter explanations and does not fully describe behavior (e.g., what happens on failure). The high-level intent is clear, but details are lacking.

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

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

Schema coverage is only 25% (only metadata and simulationScenario have descriptions). The tool has 8 parameters including nested objects. The description does not explain key parameters like 'key' or 'to', nor provide format/usage beyond the schema. It mentions return values but not parameter semantics.

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

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

The description clearly states 'Send a real transactional email via the workspace's default connector,' which is a specific verb-resource pair. It distinguishes from siblings like send_test (for test sends) and send_transactional_sms (SMS channel).

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

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

The description includes explicit instruction: 'ALWAYS confirm with the user before calling — the agent should not silently fire transactional sends.' This provides clear context of when to use the tool, though it does not explicitly mention alternatives or 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?

Annotations already mark the tool as destructive (destructiveHint: true). The description adds valuable behavioral context beyond annotations: it requires explicit user confirmation, performs preflight checks, and returns delivery and thread IDs. This helps the agent understand side effects and operational constraints.

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

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

The description is very concise at three sentences. It front-loads the core action, then adds a critical requirement, and finally summarizes internal checks and output. Every sentence adds value without verbosity.

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

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

Given the complexity (6 parameters, no output schema), the description covers key aspects: action, confirmation requirement, internal validations, and return values. However, it omits details about error conditions, idempotency semantics, and the meaning of the 'variables' object. It is adequate but not fully comprehensive.

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?

Only 17% of parameters have schema descriptions (only 'to' has one). The description does not explain the meaning or usage of parameters like 'variables', 'consentProofId', 'idempotencyKey', or 'allowExtraSegments'. While it mentions 'consent' and 'preflight', it does not link these to specific parameters, leaving agents to guess.

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

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

The description clearly states the tool's purpose: 'Send a real transactional SMS through GenieOS Messaging.' This is a specific verb+resource combination. It distinguishes itself from siblings like 'send_test' and 'send_transactional' by emphasizing 'real transactional' SMS and mentioning prerequisites like explicit user confirmation.

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

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

The description includes important usage constraints: 'Requires explicit user confirmation before calling.' It hints at prerequisites by listing 'consent, suppression, segment, sender, and Twilio preflight.' However, it does not explicitly state when to use this tool versus alternatives like 'send_test' or other send tools, leaving some ambiguity.

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