Relin

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

Annotations already declare destructiveHint=true and idempotentHint=false, but the description adds real value beyond them by disclosing the blast radius: stored records are removed, intake and delivery stop, and queued retries are cancelled. It does not address re-invocation behavior or irreversibility explicitly, which is the main remaining gap given the non-idempotent hint.

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, both earning their place: the first front-loads the destructive scope, the second states the usage condition. No filler or repetition.

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

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

For a destructive, non-idempotent, single-parameter tool with annotations covering the safety profile and no output schema, the description is nearly sufficient. Missing only practical guidance on sourcing the sourceId and confirmation of irreversibility.

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 single parameter (sourceId) is documented nowhere. The description's phrase "that source" gestures at the target but adds no meaning about the identifier's format or how to obtain it (e.g., from list_sources), so it fails to compensate for the coverage 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 names a specific verb and resource ("Delete an incoming webhook source") and enumerates the exact scope of the deletion: stored records, intake, delivery, and queued retries. This clearly separates it from sibling delete_endpoint (different resource) even though the tool name 'archive_source' might otherwise suggest a softer, reversible operation.

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 only when the user intends to remove that source" gives an explicit precondition that guards against accidental destructive invocation, and the destructive scope reinforces caution. It stops short of naming alternatives (e.g., delete_endpoint, cancel_queued_retries) or what to do instead when the intent is softer.

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 destructiveness, but description adds no further behavioral context beyond 'cancelling'. Does not disclose side effects, authentication requirements beyond stating 'Authenticated', or behavior when no jobs exist.

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

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

One sentence, 12 words, and front-loaded with 'Authenticated tool'. It is concise but could benefit from more detail without being excessively long.

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 one optional parameter, no output schema, and presence of annotations, the description is minimal. It does not clarify scope (workspace vs destination), effects on retry jobs, or error cases. More context would be needed for an AI agent to use it effectively.

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

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

Schema description coverage is 0% and the description only mentions 'workspace or destination' without explaining how workspace is specified. The single optional parameter 'destinationId' lacks any description, and the description adds minimal meaning beyond the schema.

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

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

The description clearly states the verb ('cancelling') and resource ('queued retry jobs') with scope ('workspace or destination'). It distinguishes from sibling tools like 'list_retry_jobs' and 'retry_failed_deliveries'.

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 vs alternatives. Does not mention prerequisites, when not to use it, or compare with related tools like 'retry_failed_deliveries'.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and openWorldHint=true, so the agent knows this has side effects and touches external state. The description adds useful context beyond that: it is authenticated, and the refresh targets hostname, certificate, and OIDC readiness specifically. It does not disclose what the refresh changes or any return/error behavior, so it adds moderate value 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?

A single well-formed sentence with the operation and target front-loaded and no filler. It is appropriately sized, though the brevity comes at the cost of the missing usage and parameter detail scored elsewhere.

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

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

For a one-parameter tool with no output schema and meaningful annotations, the description covers the operation but omits selection guidance and any explanation of the required portalHostId. It is minimally viable rather than fully complete.

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

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

Schema description coverage is 0% and the description never mentions the single parameter portalHostId, failing to explain what it identifies or its format. With a required parameter left undocumented in both schema and description, this gap matters more than it would for a zero-parameter tool.

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

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

The description states a specific action ('refreshing hostname, certificate, and OIDC readiness') against a clear resource ('a stable portal host'), which is more than a tautology. It does not differentiate itself from siblings such as list_portal_hosts or create_portal_host, though the readiness-check verb scope is reasonably distinct.

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

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

There is no when-to-use guidance, no mention of prerequisites or alternatives, and no exclusions. 'For a stable portal host' hints at a precondition but is not actionable selection criteria for an agent choosing among 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?

Annotations already declare this is not a read-only operation. The description adds no extra behavioral details: it does not mention idempotency, destructive potential, permissions, or side effects. It simply repeats the 'authenticated' tag, which is already implied by the tool's existence.

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

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

The description is very short (6 words), which is concise but at the cost of omitting nearly all useful information. It is not front-loaded with critical details; it merely restates the name.

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

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

Given the tool has 5 parameters, 2 required, and no output schema, the description is far too minimal. It does not explain return value, error modes, parameter dependencies, or use cases. The agent lacks enough context to invoke 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?

With 0% schema description coverage, the description must explain parameter usage, but it does not. It fails to clarify the role of 'kinds', conditional requirements (e.g., 'targetUrl' for webhook, 'targetEmail' for email), or the meaning of enum values. The agent is left guessing.

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 creates an alert channel, using a specific verb and resource. However, it does not differentiate from sibling tools like 'create_destination' or 'create_endpoint', which also create resources. The purpose is clear but lacks sibling context.

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 'list_alert_channels' or other creation tools. It does not mention context, 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 indicate a write operation (readOnlyHint=false), and the description adds that authentication is required. However, it does not disclose important behavioral traits such as whether the API key is returned only once, any irreversible consequences, or if authorization scopes are validated.

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 one sentence, which is efficient but comes at the cost of missing critical information. It earns a middle score for brevity without full effectiveness.

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

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

For a tool with two parameters and no output schema, the description is incomplete. It does not explain return values, parameter semantics, or how the tool interacts with other tools. The context is thin.

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 two parameters (name and scopes) with 0% schema coverage. The description mentions none of them, failing to add any meaning beyond the schema. The agent gets no guidance on what 'name' represents or how to use 'scopes'.

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

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

The description clearly states the action (create) and the resource (API key). It is specific and unambiguous, though it does not differentiate from sibling tools like revoke_api_key or list_api_keys.

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 like list_api_keys or revoke_api_key. The phrase 'Authenticated tool' implies it requires authentication, but this is generic and not specific to usage context.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the safety profile is covered. The description adds only the 'outbound' qualifier and product/environment scope; it says nothing about permissions, duplicate-name behavior, or side effects of registering a new webhook application.

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

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

Two short sentences with the action front-loaded and no filler. The second sentence is slightly loose ('set of customer webhook endpoints' could be read as endpoints rather than an app), but overall the text is tight.

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 0% parameter documentation, the description should at least hint at what is returned (e.g., app credentials or keys) and what the routing parameters do. It covers the name and one use case but leaves the agent under-equipped to invoke it correctly.

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

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

Schema description coverage is 0% across three parameters, and the description explains none of them. Non-obvious parameters like routingKeyHeader and routingKeyBodyPath are left entirely undocumented, so an agent cannot infer their format or meaning from either source.

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

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

States a specific verb and resource ('Create an outbound webhook application') and scopes it to 'a product or environment'. It is clearer than a tautology, but it never distinguishes itself from near-neighbors like create_endpoint, create_source, or create_destination that an agent must choose between.

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 when the user needs a new set of customer webhook endpoints' gives a usage context but no exclusions and no named alternatives. Given siblings such as create_endpoint and create_destination, the agent gets no guidance on when create_app is the right pick versus those.

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 mentions authentication but does not disclose behavioral traits such as side effects (e.g., state changes), irreversibility, or rate limits. With minimal annotation coverage, the description carries the burden but adds little beyond the tool's name.

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 of 15 words with no wasted verbiage. Every word adds value, making it highly concise for its length.

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 13 parameters, no output schema, and minimal annotations, the description is too brief. It does not explain return values, error conditions, or prerequisites (e.g., sourceId must exist), leaving significant gaps for 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?

Schema coverage is 0%, so the description must compensate. It groups parameters into 'retry policy and optional filters', but this is too vague given 13 parameters. No per-parameter details are provided, leaving the agent to infer meaning from names alone.

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

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

The description specifies the verb 'creating' and resource 'outbound destination and connection', clearly distinguishing it from sibling tools like create_source or create_endpoint. However, it could be more precise about the exact nature of the 'connection' and how it relates to other similar constructs.

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 like create_endpoint. The description only states it is authenticated, but does not provide context on prerequisites or situations where other tools are preferable.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false and destructiveHint=false, so the write/non-idempotent profile is covered structurally. The description adds only 'HTTPS' as a hard requirement, and its claim of configuring 'retry settings' is not backed by any retry parameter in the schema, which risks misleading the caller; it never warns that the non-idempotent create can produce duplicate endpoints on retry.

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 compact sentences with the core action front-loaded and no filler. Sizing is appropriate for a create tool, though the trailing 'using the requested customer and URL' is mildly redundant.

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?

A mutating tool with 6 parameters, 0% schema coverage, no output schema and no annotations explaining auth or permissions should do substantially more. The description leaves half the parameters unexplained and omits any statement of what is returned or what happens to existing subscriptions.

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 carry parameter meaning. It only gestures at three of six parameters (recipient as 'customer', url, eventTypes as 'event subscriptions') and never explains appId, name, or recipientName; the referenced 'retry settings' parameter does not exist in the schema.

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

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

States a specific verb (Add) and resource (HTTPS webhook endpoint) scoped to a customer of an outbound app, which separates it from generic siblings like create_destination or create_source. It is clear what the tool produces, though it never explicitly contrasts itself with update_endpoint or ensure_webhook_setup.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as update_endpoint (for existing endpoints) or ensure_webhook_setup. The agent learns what the tool does but not when it is the right choice among 50+ 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 declare write, non-idempotent, open-world behavior, and the description adds meaningful side-effect context beyond them: it 'creates portal access configuration and may provision a hostname and certificate.' The word 'may' usefully signals non-determinism, though permissions requirements and whether certificate provisioning can fail or be retried are left implicit.

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 the usage gate, then the effect. Every sentence carries information and there is no filler; only the effect sentence's 'may provision' could be sharpened.

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 10-parameter mutation with no output schema and no per-parameter schema descriptions, the description adequately frames what the tool does and when to use it but leaves input semantics largely unexplained. An agent could select it correctly but would be guessing on most optional claims fields.

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% across 10 parameters, so the description carries the full explanatory burden. It only gestures at two clusters ('application and identity-provider configuration') and says nothing about hostname, oidcScopes, nameClaim, emailClaim, recipientClaim, or allowedEmailDomain — leaving half the inputs undocumented anywhere.

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

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

States a concrete verb and resource ('Configure a customer webhook portal on a domain the user controls, with their existing OpenID Connect identity provider'), which clearly separates it from read-oriented siblings like check_portal_host and list_portal_hosts. It doesn't explicitly name the nearest alternative (save_portal_settings), so sibling differentiation is implied rather than stated.

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

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

Gives an explicit activation condition: 'Use only when the user asks to set up a portal domain and supplies the application and identity-provider configuration.' That is a real when-to-use gate backed by required inputs. It stops short of naming when-not or pointing to the settings/list alternatives for partial setups.

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 the mutation/access profile (readOnly=false, idempotent=false, destructive=false). The description adds genuinely useful context beyond them: the link is 'temporary', it 'grants access to that customer's webhook controls', and it carries a security warning. It stops short of explaining expiry defaults or that each call mints a fresh link.

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

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

Two tight sentences: purpose first, security caution second. Nothing is redundant and the critical constraint is front-loaded.

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

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

For a 7-parameter, nested-object mutation tool with no output schema and 0% schema coverage, the description explains only the high-level intent. It omits what the call returns (URL/expiry), how long the session lasts by default, and most parameter meaning, so an agent lacks enough to invoke it confidently.

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

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

Schema description coverage is 0%, so the description must carry the param burden, yet it only maps to the two required fields (appId, recipient). The other five parameters (theme, returnUrl, capabilities, recipientName, expiresInSeconds) get no mention, leaving a large 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?

States a specific verb ('Create') and resource ('temporary customer webhook portal link') scoped to an app and recipient. It is clearly distinguishable from siblings like create_portal_host and check_portal_host, though it never names those alternatives explicitly.

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

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

No guidance on when to use this versus related portal tools (create_portal_host, check_portal_host, get_portal_settings). The only usage note is the security caution 'share only with the intended user', which is context, not when-to-use routing.

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 (readOnlyHint=false, destructiveHint=false) indicate a write operation, which is consistent with 'create'. However, the description adds no behavioral details beyond that, such as side effects, permissions required, or rate limits. Given no annotation enrichment, this is insufficient.

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

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

The description is very short (one sentence), which is concise but at the expense of completeness. It front-loads 'Authenticated' but contains no structured information. It could be improved without adding length.

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 many sibling tools, the description is critically incomplete. It does not explain what a 'source' is, what the tool returns, or how it differs from similar creation tools. The agent lacks essential context to use it correctly.

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

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

Schema coverage is 0%, meaning the description must explain parameters, but it provides no parameter information. The three parameters (name, vendor, signingSecret) are not described at all, leaving the agent to infer meaning solely from the schema, which is minimal.

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 source' clearly, a verb+resource. However, it does not distinguish from sibling tools like 'create_destination' or 'create_endpoint', which also create resources. The purpose is clear but lacks 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?

No guidance on when to use this tool versus alternatives. The description only mentions 'Authenticated', which is a prerequisite, not usage context. There is no mention of when creating a source is appropriate or what conditions must be met.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false, so safety is partly covered. The description's framing as a mere 'disable' softens what the annotations call a destructive operation, and it says nothing about reversibility, what happens to in-flight deliveries, or required permissions. This tension is a real risk for an agent deciding whether the call is safe.

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

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

A single short sentence, front-loaded with the verb and resource, with no filler. Nothing is wasted.

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

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

For a destructive, non-idempotent mutation with two undocumented required parameters and no output schema, the description is too thin. It omits parameter meaning, reversibility, and the delete-vs-disable distinction that an agent needs to call it correctly.

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

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

Both parameters (appId, endpointId) have 0% schema description coverage and the description adds no meaning for either. With low coverage the description is expected to compensate, and it does not mention parameters at all.

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

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

States a specific verb (disable) plus the resource (customer webhook endpoint) and the effect (no longer receives events), which is more than the title alone gives. However, the verb contradicts the tool name 'delete_endpoint', leaving an agent unsure whether the endpoint is removed or merely deactivated. It also does not distinguish the action from siblings such as update_endpoint.

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

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

There is no guidance on when to use this versus update_endpoint, archive_source, or revoke_api_key, and no prerequisites or conditions given. The only usage signal is the implied effect of stopping event delivery.

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 readOnlyHint=false, and the description usefully narrows that: the record is archived, not purged, and existing subscriptions are unaffected because only new selections are blocked. It omits reversibility (can the archive be undone?) and any permission requirements, which keeps it short of a 5.

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

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

One sentence, front-loaded with the action and scoped by the effect; no filler and no repetition of the title.

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

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

For a two-parameter mutation with annotations covering the safety profile and no output schema, the description covers what happens to the event type but not idempotency behavior (annotations say idempotentHint=false, so repeat calls may fail, which matters given the word 'archive' implies idempotence), nor permissions.

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 carries the full burden for appId and eventType, and it says nothing about either — no format, no hint that eventType is an identifier string, no relationship between appId and eventType. With two required, undocumented parameters this is a real 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 names a specific verb and resource ("Archive an outbound event type") and immediately clarifies that the operation is a soft archive rather than a hard delete, correcting the misleading 'delete' in the tool name. It does not explicitly differentiate itself from upsert_event_type or list_event_types, but the scope is unambiguous.

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

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

It states the effect ("customers can no longer select it for new subscriptions") but gives no when-to-use guidance, no prerequisites, and no pointer to an alternative such as upsert_event_type for re-enabling or modifying an event type.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows it's a safe, idempotent read operation. The description adds context about what the tool explains (webhook intake, delivery, replay, anomaly review), which is beyond the annotations but does not disclose additional behavioral traits like response format or length. This is acceptable for a simple descriptive tool.

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

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

The description is a single sentence that is clear and front-loaded. It contains no extraneous information and is appropriately sized for the tool's 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 the tool has no output schema, the description is mostly complete by stating what it explains. However, it does not specify the output format (e.g., textual explanation, JSON). The simplicity of the tool and the annotations make this a minor gap.

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

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

There are no parameters, so the baseline is 4. The description does not need to add parameter information, and the schema coverage is 100% by default.

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: 'Explain what Relin does and how agents should use it for webhook intake, delivery, replay, and anomaly review.' It uses a specific verb ('explain') and resource ('Relin'), and distinguishes itself from sibling tools, which are operational (create, list, 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?

The description provides clear context on when to use the tool: to get an explanation of Relin and guidance on its usage for specific tasks. However, it does not explicitly state when not to use it or mention alternatives, though no sibling tool offers the same function.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=false, so the write/safety profile is covered structurally. The description adds real behavioral value by explaining the divergent return payloads per vendor and the Stripe authorization handshake. It omits side effects: whether repeat calls create duplicate setups (notable given the 'Ensure' naming versus idempotentHint=false), required permissions, and what configuration the 14 optional parameters actually trigger.

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 tight sentences with the general purpose front-loaded and the provider-specific branching immediately after. No filler, though the Stripe/other split could be structured more scannably given the number of distinct outcomes.

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 16-parameter, non-idempotent mutation tool with no output schema and 0% schema description coverage, the description covers only the high-level flow and return shape. It does not address the parameter space, idempotency/duplicate behavior, or permission requirements, leaving significant gaps an agent must guess at.

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% across 16 parameters, so the description must carry the semantic load and largely does not. It only implies vendor and destinationUrl usage via the provider branches, leaving signingSecret, destinationSigningSecret, filterBodyPath/Value, transformExpression, retry and rate-limit parameters entirely unexplained in both schema and 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?

States a specific verb and resource ('Set up incoming webhooks and delivery rules') and branches into provider-specific outcomes (Stripe authorization link vs. ingest URL for others). It does not distinguish itself from siblings like create_endpoint or create_destination, which also appear to create webhook-related resources, so the boundary is left to inference.

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

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

Gives one concrete follow-up route ('after authorization, use get_webhook_setup_status to verify receipt and delivery'), which is genuine when-to-use guidance for the Stripe path. However, it never says when to prefer this tool over create_endpoint, create_source, or create_destination, nor what prerequisites (existing destination, source, signing secret) must hold before calling.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world behavior, so the safety profile needs no restatement. The description adds that this is an outbound webhook application and that it returns configuration, but says nothing about not-found handling or required scopes.

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

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

One sentence, front-loaded with the operation and resource, with zero filler or redundancy.

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

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

For a read-only single-parameter getter with annotations covering the safety profile and no output schema, the description states operation, resource, key, and the kind of data returned. Only error/not-found behavior and permission requirements are unaddressed, which is a minor gap at this complexity.

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

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

Schema description coverage is 0% for the single required appId parameter, so the description carries the burden; it identifies the parameter as the 'app ID' of the application, which matches and mildly clarifies the schema field, but adds no format, source, or validation detail.

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

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

Specific verb (read) plus resource (outbound webhook application) and the lookup key (app ID), with the intent 'to inspect its configuration'. It is clearly distinguishable from create_app and list_apps, though it does not name those siblings explicitly.

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

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

'by its app ID' implies the precondition for this tool (you must already hold an ID) and implicitly contrasts with list_apps for discovery, but there is no explicit when-to-use/when-not-to-use statement or named 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds that the payload includes event subscriptions and delivery settings, which is useful scoping context but not deep behavioral detail such as shape or freshness.

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

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

A single well-formed sentence with the operation front-loaded and no filler. It is tight, though slightly thin given the retrieval has no output schema backing it.

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

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

With no output schema, the description sensibly names the returned sections, so an agent knows roughly what comes back. However, it leaves both required parameters undocumented in schema and prose, which is a meaningful gap for a two-parameter lookup.

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 neither appId nor endpointId is explained anywhere. The description only implies 'endpoint' via the noun phrase, and says nothing about how appId scopes the lookup or what identifier formats are accepted.

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

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

Names a specific verb ('Read') and resource ('customer webhook endpoint') and even enumerates what is returned (event subscriptions, delivery settings). It is distinguishable from the list_endpoints sibling by being a singleton read, though it never states that distinction explicitly.

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

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

No when-to-use guidance, no prerequisites, and no mention of the obvious alternatives (list_endpoints for enumeration, update_endpoint for modification, delete_endpoint for removal). The usage is only inferable from the verb.

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 the tool as read-only and idempotent. The description adds that it includes attempts, deliveries, and optional raw payload, which goes beyond annotations by specifying what data is returned. No contradictions exist.

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

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

A single sentence of 10 words efficiently conveys the tool's purpose and key features. It is front-loaded with 'Authenticated tool for reading' and contains no redundant 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?

Without an output schema, the description partially covers return content (attempts, deliveries, payload) but lacks specifics on structure, fields, or error conditions. For a read tool, this is adequate but not thorough.

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 links 'optional raw payload' to the includePayload parameter but does not explain eventId or provide format details. This adds moderate value but leaves gaps for the 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?

The description clearly states the tool reads one event, including attempts, deliveries, and optional raw payload. It distinguishes from siblings like list_recent_events by focusing on a single event with detailed nested data.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives like list_recent_events or get_message. The term 'Authenticated' hints at access requirements but does not contextualize usage among similar tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds that the response includes delivery state, which is modest extra context beyond the structured fields.

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

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

A single front-loaded sentence with no filler; the resource and its identifiers come first, the returned state second. Nothing extraneous.

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 should sketch the return shape, and 'delivery state' is only a gesture toward it. For a simple two-parameter read tool with full annotation coverage this is adequate but leaves what 'delivery state' contains undefined.

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 carry the load. It ties both parameters to their concepts ('app and message IDs'), mapping appId and messageId, but gives no format, sourcing, or constraint details for either required 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?

States a specific verb (Read) and a tightly scoped resource (one outbound webhook message) plus the extra data returned (its delivery state). The singular 'one' implicitly separates it from the sibling list_messages, though no sibling is named explicitly.

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

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

Usage is implied by the singular retrieval framing and the requirement for both IDs, but the description never says when to prefer this over list_messages or get_event_detail, nor any prerequisite for obtaining the IDs. Implied usage only.

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 read-only, idempotent, non-destructive behavior. The description adds value by specifying the types of metrics (delivery, failure, duplicate, open-issue) beyond what annotations provide, though it does not mention rate limits or authentication details beyond stating 'Authenticated'.

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 (7 words, one sentence), which is efficient. However, it omits critical information about parameters and usage, so conciseness comes at the cost of completeness.

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

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

Given the single parameter and no output schema, the description does not sufficiently explain input requirements (windowHours) or output format. While annotations provide safety context, the description lacks details needed for correct invocation.

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

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

The schema has one parameter (windowHours) with no description, and the tool description does not explain its purpose, usage, or impact. With 0% schema description coverage, the description fails to compensate, leaving the agent uninformed.

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 provides rollups for delivery, failure, duplicate, and open-issue metrics, distinguishing it from sibling tools that list individual items. However, 'rollups' is somewhat vague and does not specify the format (e.g., counts, averages).

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 sibling tools like list_open_issues or list_delivery_attempts. It does not provide context or alternatives, leaving the agent to infer usage.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, indicating safe read behavior. The description adds 'Authenticated' but lacks additional behavioral details such as error handling or response format.

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

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

The description is a single, well-structured sentence that conveys the core purpose without unnecessary words, making it concise and easy to parse.

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

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

For a simple read tool with one parameter and no output schema, the description is adequate but minimal. It covers purpose but omits important context like return value details or when to use compared to siblings.

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

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

Schema coverage is 0%, requiring the description to explain the 'appId' parameter. The description only mentions 'for an app' generically, without specifying the parameter's meaning, format, or relationship to other 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?

The description clearly states the verb 'reading' and the resources 'portal branding defaults and host setup' for an app, distinguishing it from sibling tools like 'save_portal_settings' or 'check_portal_host'.

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 'Authenticated tool' but does not provide explicit guidance on when to use this tool versus alternatives like 'check_portal_host' or 'list_portal_hosts', nor any exclusions or prerequisites.

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

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

Annotations already provide readOnlyHint, idempotentHint, and not destructive. The description adds that the output is concise setup guidance, but does not disclose additional behavioral traits like response format or potential errors.

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 front-loads the purpose with no wasted words. The description is as concise as possible given the tool's simplicity.

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

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

For a simple read-only tool with one enum parameter and no output schema, the description covers the essential purpose. Minor gap: no mention of what the guidance contains, but still largely 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 'provider' parameter, and the description does not explain its role or the enum values. The description only implies the provider choice via 'connecting a webhook source and destination', 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 tool returns concise setup guidance for connecting a webhook source and destination. It distinguishes from siblings like ensure_webhook_setup (which performs setup) and list_supported_webhook_shapes (which lists shapes).

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 like ensure_webhook_setup or list_supported_webhook_shapes. The description does not mention prerequisites, context, 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds that the tool is 'Authenticated,' providing minor behavioral context beyond annotations, but no additional safety or side-effect details.

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

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

Single sentence with no wasted words. Front-loaded with the key action and outputs.

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 sufficient for a simple read-only tool with no parameters and no output schema. It specifies the return values (two URLs). Could optionally mention the purpose of the URLs, but not required.

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

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

The tool has no parameters, and schema coverage is 100%. The description does not need to add parameter information; the baseline is 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?

The description clearly states the tool returns the dashboard Slack OAuth connect URL and expected redirect URL, specifying the verb and resources. It distinguishes itself from sibling tools which are mostly CRUD operations on other entities.

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 versus alternatives. However, the tool's purpose is self-explanatory given its name and description, so usage is implied but lacks explicit 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 readOnly/idempotent/non-destructive, and the description adds real behavior on top: it returns a secure Stripe authorization link when needed and explicitly reassures the agent not to recreate or rotate anything on re-call. This is useful context beyond the safety hints, though return shape and any auth requirements are not detailed.

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 tight sentences, front-loaded with what is checked, followed by the Stripe special case and the re-call instruction. No filler; each sentence carries 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?

With no output schema, the description properly enumerates the return contents and the conditional Stripe auth link, which is the key thing an agent needs. For a single-param read tool this is nearly complete; only sourceId semantics remain thin.

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?

One parameter (sourceId) at 0% schema coverage means the schema provides no documentation, so the description must compensate. 'Check a source's ...' implies that sourceId identifies the source, adding marginal meaning, but it gives no format, ID type, or lookup 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?

States a specific verb (Check) and enumerates exactly what the response aggregates: provider connection, enabled destinations, signature-verified events, and delivery attempts. It is clearly a status/diagnostic read distinct from the mutating siblings. It stops short of naming the nearest sibling (ensure_webhook_setup), so it is differentiated more by detail than by explicit contrast.

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

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

Gives concrete usage context: call it to check, then 'call again after the user connects'. That polling instruction is a genuine when-to-use signal. It does not, however, state when to prefer it over ensure_webhook_setup or other setup tools, so no explicit alternatives 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 indicate read-only and idempotent behavior. The description adds 'Authenticated tool', which is useful but minimal. No further behavioral traits like pagination or rate limits 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 a single concise sentence with no wasted words. It could benefit from more structure, but it is appropriately sized for a simple tool.

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

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

For a list tool with no parameters, the description provides basic information (resource and auth). However, it lacks details about return values or how it differs from similar list tools, making it minimally adequate.

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

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

The tool has no parameters, and the description adds no further info. Given the baseline for 0 parameters is 4, and schema coverage is 100%, this score 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 alert channels using a specific verb and resource. However, it does not differentiate from multiple sibling list tools, which could cause confusion.

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

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

No guidance is provided on when to use this tool versus alternative list tools (e.g., list_destinations). The context is implied but lacks explicit usage directions.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description's addition of 'Authenticated' provides useful context about required credentials, which is beyond annotations. However, it does not elaborate on failure modes or rate limits.

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

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

The description is a single sentence with no unnecessary words. It is front-loaded and efficiently conveys the essential 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?

The tool is simple (no params, no output schema), but the description omits what the returned list contains (e.g., key IDs, names). While annotations cover safety, listing tools typically benefit from output hints. Adequate but not thorough.

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 0 parameters with 100% description coverage, so the description adds no param info needed per baseline guidelines (0 params = baseline 4). No further semantic context is required.

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

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

The description clearly states 'list API keys' as the action and resource, and 'Authenticated tool' distinguishes it from unauthenticated tools. It is specific and avoids tautology.

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

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

The description implies usage for listing keys but does not provide explicit guidance on when to use this tool versus alternatives like create_api_key or revoke_api_key. No when-not-to-use or alternative context is given.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety and idempotency are covered structurally. The description adds only the workspace scoping and the dependency role; it says nothing about result size, pagination, or ordering.

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

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

Two tight sentences with no filler. The resource being listed comes first and the workflow purpose follows, which is the right 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?

For a no-parameter, read-only listing tool with no output schema, the description covers what is listed and why it matters. Only minor omissions remain (pagination/return shape), which are not required to call it correctly.

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

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

The tool takes no parameters, so there is no per-parameter semantics to explain; the baseline for a zero-parameter tool is 4. Nothing in the description misrepresents or omits parameter behavior.

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

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

States a specific verb and resource ('List outbound webhook applications') and scopes it to 'the connected Relin workspace'. This clearly separates it from siblings like list_endpoints, list_destinations, and list_sources, which deal with different resources.

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

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

Explicitly states the use case: 'find the app ID before managing customer endpoints or sending events', which gives the agent a clear workflow trigger. It lacks any when-not guidance or named alternative, but the context is unambiguous.

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

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

Annotations already indicate read-only and non-destructive behavior. The description adds only 'authenticated', which is implied, and provides no additional behavioral context.

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

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

The description is concise in one sentence, but it is too brief to be useful, lacking structure and detail.

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

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

Given 5 parameters, no output schema, and many sibling list tools, the description is incomplete. It does not cover return format, pagination, or filter 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?

The description mentions 'with filters' generically but does not explain the meaning, format, or constraints of any of the 5 schema parameters (limit, since, status, eventId, destinationId). Schema coverage is 0%.

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

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

The description states the tool lists fanout delivery attempts with filters, but does not differentiate it from sibling tools like list_message_attempts or list_messages, which could be confused.

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., list_message_attempts) or prerequisites beyond authentication.

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 destructiveHint=false. The description adds 'Authenticated', indicating auth requirements, and specifies the content (outbound destinations and retry policy). No contradictions.

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

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

The description is a single sentence of 8 words, which is concise but lacks structure. It is front-loaded but omits necessary 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?

With only one parameter and no output schema, the description is incomplete. It does not explain what fields are returned, how filtering works, or provide enough context for a simple list tool.

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

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

The input schema includes one parameter (sourceId) with 0% description coverage. The description does not mention or explain the parameter, failing to add meaning beyond the schema.

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

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

The description clearly states it lists outbound destinations and retry policy, using a specific verb and resource. Among sibling list tools, it is distinct by name, but no explicit differentiation is provided.

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 like list_endpoints or list_sources. The description does not provide context for appropriate usage 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 readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds the notion of 'delivery settings' being included, which is useful context beyond annotations, but doesn't describe pagination or return shape.

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

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

A single efficient sentence with no waste. It is front-loaded and appropriately sized for a simple list operation.

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

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

For a two-parameter tool with no schema descriptions and no output schema, the description should clarify what 'recipient' filters and what fields the listing returns. It leaves the filtering behavior opaque.

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

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

Schema coverage is 0% and neither parameter is explained. appId is required but the description only implicitly ties the listing to an app; the 'recipient' parameter is completely unexplained despite being a likely filter.

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

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

States a specific verb (List) and resource (customer webhook endpoints and delivery settings) for an outbound app. It's distinguishable from create_endpoint/delete_endpoint/get_endpoint, though it doesn't explicitly mention how it differs from siblings like list_destinations.

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

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

No guidance on when to use this versus get_endpoint (single) or other list tools. The 'for an outbound app' hints at scoping but doesn't state preconditions or alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered elsewhere. The description adds only the 'customer-subscribable, outbound app' scoping context; it says nothing about pagination, freshness, or return shape.

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

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

A single well-formed sentence with the resource and scope front-loaded and no filler. It is efficient, though arguably too terse given the unanswered questions about the parameter and output.

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

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

For a simple read-only, one-parameter list tool with no output schema, the description is minimally adequate. It omits whether results are paginated or how appId is obtained, which are the remaining details an agent would want.

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% for the single appId parameter, so the schema explains nothing. The phrase 'for an outbound app' hints that appId scopes the listing, but it never states that appId is required or what form it takes, leaving the compensation partial.

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

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

The description states a specific verb (List) and resource (event types) and adds scope: 'customers can subscribe to for an outbound app'. That scope meaningfully distinguishes it from upsert_event_type and delete_event_type, though it never names a sibling explicitly.

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

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

There is no when-to-use guidance. With siblings like list_supported_webhook_shapes, get_event_detail, and upsert_event_type in the same domain, the agent gets no help choosing among them, and no prerequisites or exclusions are given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description usefully discloses what the results contain (returned status and errors), but says nothing about pagination via 'limit', ordering, or what happens when the message has no attempts.

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

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

Two tight sentences with zero filler, the purpose front-loaded before the usage hint. Nothing is redundant or restating the title verbatim.

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

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

There is no output schema, so the description's brief list of returned fields (status, errors) is helpful, and annotations cover safety. However, with 0% parameter coverage and a limit parameter whose semantics are unexplained, a few more words on pagination and required IDs would materially improve call correctness.

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 all three parameters (appId, messageId, limit) are undocumented in the schema. The description compensates for none of this: it never mentions the limit cap of 100, pagination/cursor behavior, or that appId and messageId are required identifiers. With low coverage the description carries the burden and fails to.

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

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

The description states a specific verb and resource: inspect delivery attempts for an outbound webhook message, with the additional scope of status and errors. It is clear on its own, but it does not differentiate from the near-identical sibling 'list_delivery_attempts', which an agent could easily confuse with this tool.

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

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

It gives an intended use case (verify delivery or diagnose failures), but that is essentially the same reason an agent would call any delivery-attempt listing tool, so it does not actually route the agent between 'list_delivery_attempts', 'list_messages', and 'get_message'. No exclusions or alternative-routing guidance are provided.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered structurally. The description adds only the outbound/send-history scoping and nothing behavioral beyond that, such as ordering, pagination behavior, or result shape.

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

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

Two tight sentences with the core purpose front-loaded and the routing hint immediately after; nothing is padded. The only cost is that the filter clause is imprecise relative to the actual schema, which makes the brevity slightly misleading rather than merely efficient.

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

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

For a read-only list tool with full annotation coverage and no output schema, the description is minimally sufficient: the agent knows what it lists and when to use it. It is incomplete on the parameters, since q, appId and limit go entirely undocumented, and the mentioned filters do not map cleanly onto the schema.

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

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

Schema description coverage is 0% across three parameters, so the description must carry the load and does not. Worse, it claims filtering 'by customer or event type' while the schema exposes only q, appId and limit, and it never explains what q searches or that limit caps at 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?

States a specific verb and resource ('List outbound webhook messages for an app') and scopes it to the outbound direction, which separates it from get_message (singular) and list_message_attempts. The second sentence explicitly contrasts it with incoming vendor events, so an agent can route without opening the schema, though no sibling tool is named directly.

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

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

'Use this for send history rather than incoming vendor events' gives a clear when-to-use plus one explicit when-not condition. However, it offers no guidance on choosing between this and list_message_attempts, list_recent_events, or get_message when an agent needs attempt-level detail.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds only 'authenticated', which is minor behavioral context beyond what annotations provide, and does not disclose any additional side effects or behavioral traits.

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 at two sentences, with the first sentence defining the tool's purpose and the second providing key usage guidance. Every sentence earns its place with no wasted words, and the most critical information is front-loaded.

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

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

The description covers the filtering functionality well but does not describe the return value or structure of the output, especially since no output schema is provided. While the annotation set is rich, the lack of output information leaves some ambiguity about what the agent will receive.

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 100% description coverage for all 4 parameters. The tool description adds significant value by explaining the smart lookup behavior of the `q` parameter, which is not fully captured in the schema description. This enhancement helps agents understand how to effectively use the filtering capability.

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 open anomaly and delivery issues, specifying the exact resource and action. It distinguishes from other list tools by focusing on open issues specifically, providing a specific verb-resource combination.

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 offers guidance on using the `q` parameter for smart lookups but does not explicitly state when to use this tool instead of alternatives like `list_messages` or `list_sources`. The context of when to use vs. not use is implied but not clearly articulated.

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 destructiveHint=false, so the description adds minimal value (only 'authenticated'). No contradiction, but no additional behavioral context.

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

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

Single sentence, no fluff, directly states purpose. Efficiently structured.

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

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

Adequate given simple tool with one parameter and good annotations, but lacks description of return value (list of hosts) and what 'stable' means.

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%; description mentions 'for an app' but does not explain appId's meaning or format. The parameter remains largely undocumented.

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

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

The description clearly states the tool lists 'stable portal hosts for an app', which is specific and distinct from siblings like create_portal_host or check_portal_host.

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

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

The description implies use when listing hosts but provides no explicit guidance on when to use this over related tools like check_portal_host or get_portal_settings.

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 destructiveHint=false, so the description adds minimal behavioral context beyond 'Authenticated'. The description hints at filtering by signature status and duplicates but doesn't elaborate on pagination or scope of 'recent'.

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, very concise. However, it may be too brief given the tool's complexity, sacrificing necessary detail.

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

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

No output schema, no description of return values, and parameter semantics are missing. The description only covers the tool's purpose superficially, leaving significant gaps for effective 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?

With 0% schema description coverage and 5 parameters, the description provides no explanation for any parameter (q, limit, sourceId, signatureStatus, failedDeliveryOnly), leaving the agent to guess 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 the tool inspects recent received events, including duplicates and signature status, aligning with the name 'list_recent_events' and distinguishing it from sibling tools like get_event_detail (single event) or list_messages.

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

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

No guidance is provided on when to use this tool versus alternatives such as get_event_detail or list_messages, nor are there any prerequisites or exclusions mentioned.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds useful domain context (recipients = customers configured for outbound webhooks) but says nothing about pagination, result volume, or return shape.

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

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

Two tight sentences with zero waste; the core purpose is front-loaded and the follow-up sentence earns its place by clarifying downstream use of the output.

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

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

For a simple one-parameter read tool with annotations covering safety and no output schema, the description covers purpose and output usage adequately. The only real gap is the unexplained appId parameter, which prevents a 5.

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% for the single required appId parameter, and the description only hints at app scoping with the phrase 'for an app' without naming or explaining the identifier. It fails to compensate for the coverage 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?

States a specific verb (List) and resource (customers configured to receive outbound webhooks for an app), which effectively defines what a 'recipient' is. It does not explicitly differentiate itself from the many sibling list_* tools, so it lands just short of a 5.

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

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

The second sentence explains what to do with the results (use customer identifiers for endpoint and message operations), which implies usage, but there is no explicit when-to-use/when-not or comparison against alternatives like list_endpoints or list_destinations.

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, destructiveHint=false, and idempotentHint=true. The description adds 'authenticated', which is additional context. No contradictions. The description does not elaborate on behavior beyond authentication, but the safety profile is well-covered by annotations.

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

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

The description is a single, short sentence with no extraneous information, which is concise. However, the brevity sacrifices useful content; it could be longer to include parameter details without being verbose.

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

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

Given the simple nature of the tool (2 optional parameters, no output schema), the description is incomplete. It does not mention that the tool returns a list or that results can be filtered by status and limit. Contextual completeness is low.

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

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

Schema description coverage is 0%, meaning no parameter descriptions. The tool description does not mention or explain the two parameters (limit, status), leaving their semantics entirely to the schema. The tool description should compensate given 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 'list' and resource 'retry jobs', making the primary purpose unambiguous. However, it does not explicitly differentiate it from sibling list tools, but the resource name is sufficiently distinct.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., other list tools or filters). The description lacks any context about appropriate use cases 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 indicate readOnlyHint, idempotentHint, and destructiveHint. The description adds 'Authenticated' which is vague and common, not providing meaningful 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?

The description is very concise (4 words) but under-specified. It lacks necessary detail without being notably 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 should provide context about what a source is or the return format. It fails to do so, leaving the agent without sufficient information.

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

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

With 0 parameters, baseline is 4. The description does not need to add parameter information, but it could have clarified the scope of 'sources'.

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 'list sources' which is a specific verb and resource. However, it does not differentiate this tool from sibling tools like list_messages or list_apps.

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 create_source or archive_source.

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 read-only, idempotent, and non-destructive behavior. The description adds meaningful context about what the shapes represent (event identity, ordering, gap checks), enhancing 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, concise sentence that front-loads the action and purpose without any 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?

The description is complete enough for a simple list tool with no parameters and no output schema. It explains what the list contains and its purpose, though it does not describe the output format.

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

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

There are no parameters, so the schema covers 100% of the parameter semantics. The description does not need to add parameter details, and the baseline for no parameters is 4.

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

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

The description clearly states the verb 'List' and the resource 'vendor webhook shapes', along with their purpose for event identity, ordering, and gap checks. It distinguishes itself from sibling list tools by specifying 'vendor webhook shapes'.

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 does not provide explicit guidance on when to use this tool versus alternatives. While the context is clear for what it does, no usage conditions or exclusions are given.

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

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

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=true). The description adds two genuinely useful facts beyond that: the operation requires authentication and it is asynchronous ('queueing' rather than immediate replay). It stops short of the duplicate-creation risk implied by idempotentHint=false or of any confirmation/permission detail.

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

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

A single front-loaded sentence with no filler, and the auth note comes before the action. It is appropriately sized, though its brevity reflects thin content rather than disciplined editing.

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 undocumented required parameter and no output schema, the description omits key facts: where eventId comes from, what 'queueing' means for the eventual delivery, and whether repeated calls are safe. The annotations carry the safety profile, but the operational context is incomplete.

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

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

Schema description coverage is 0% and the sole parameter eventId has only a minLength constraint, with no format, source, or example. The description contributes only the weak implication that the id refers to an already 'received' event; it does not tell the agent where to obtain the id or how it is shaped.

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

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

The description gives a specific verb+resource ('queueing a replay of a single received event'), and the word 'single' implicitly distinguishes it from the bulk sibling replay_events. However, it never names that sibling, so an agent must infer the scope contrast from the plural tool name rather than from explicit wording.

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

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

There is no explicit when-to-use guidance, no prerequisites, and no mention of alternatives such as replay_events, replay_message, or retry_failed_deliveries. Only a faint signal ('single') hints at the bulk-vs-individual distinction, leaving the agent to guess which replay/retry tool fits.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, non-idempotent and open-world, so the safety profile is largely covered. The description contributes two useful facts those annotations do not carry: the tool is authenticated, and the action is queued rather than executed synchronously. It stops short of saying whether a replay can be duplicated or how queued work is tracked, which matters for a non-idempotent 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?

A single well-formed sentence that front-loads the action ('queueing replay') followed by the scoping dimensions. It is dense but has no filler, and it loses a point only because the filter list crowds out the routing/disambiguation information an agent most needs.

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 non-readonly, non-idempotent, open-world tool with six completely undocumented parameters and no output schema, the description covers authentication, queuing semantics and the filter axes, but omits what the call returns (a job identifier?), any duplicate-replay safeguards, and any bounds on scope. Adequate but with clear gaps for an agent about to enqueue a bulk operation.

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

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

Schema description coverage is 0%, so the description must carry the burden, and it does map names to meanings for q, sourceId, signatureStatus, failedDeliveryOnly and windowHours. But it adds no format, unit, range, or accepted-value detail (e.g. valid signatureStatus strings, windowHours bounds), and limit is never mentioned, so compensation is only partial.

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

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

States a specific verb ('queueing replay') and enumerates the filter dimensions (source, query, signature status, failed-delivery state, time window), so an agent knows this enqueues a filtered bulk replay. It does not, however, distinguish itself from the close siblings replay_event and replay_message, leaving the agent to infer that this one is the plural/bulk variant.

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

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

There is no when-to-use guidance: nothing says whether to prefer this over replay_event, replay_message, or retry_failed_deliveries, and no prerequisites or preconditions are stated. The filter list implies scoping but never tells the agent when this tool is the right choice versus a single-event or single-message replay.

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

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

Annotations already disclose readOnly=false, idempotent=false, and openWorld=true, but the description adds genuinely new context beyond them: re-sending 'may repeat actions at customer endpoints', which warns of duplicate downstream side effects. It does not cover permissions or rate limits, so not a 5.

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

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

Two tight sentences with the action front-loaded and the risk warning second. Nothing is wasted and nothing needs reordering.

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

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

For a two-parameter mutation with no output schema, the description covers the essential risk (duplicate endpoint actions) and the scope restriction. The remaining gap is parameter meaning, which is thin but recoverable from self-descriptive names.

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% for both required parameters, so the description carries the full burden of explaining appId and messageId. It references 'the message' only obliquely and says nothing about what appId scopes or the expected identifier format, so it does not compensate for the 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?

States a specific verb and resource: 'Send an existing outbound webhook message again'. The singular 'message' implicitly separates it from replay_events and replay_event, but no sibling is named, so the agent must infer the boundary rather than read it.

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

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

'use only for the message the user wants replayed' is a scoping caution that implies when not to use it broadly, but it never names alternatives (replay_event, replay_events, retry_failed_deliveries, send_message) or the condition that should select one over the other.

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

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

Annotations indicate destructiveHint=true, but description adds no extra behavioral context (e.g., whether resolution is reversible, side effects). The description merely restates the action already implied by the tool name and annotations.

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

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

Single sentence, 13 words, no fluff. Every word contributes to understanding the tool's 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?

Despite having one parameter and no output schema, the description omits critical context like confirmation, return value, error conditions, or the fact that it is destructive (already in annotations but could be reinforced). For a mutation tool, more detail is warranted.

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 clarifies that the parameter anomalyIds should contain anomaly IDs, which adds basic meaning beyond the schema (which has no descriptions). However, it does not explain the expected format or any validation beyond schema 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?

Description clearly states the action ('marking resolved'), resource ('anomalies'), and identifier ('by anomaly_id'). It is specific and distinct from sibling tools which mostly deal with endpoints, events, 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?

No guidance on when to use this tool versus alternatives. Does not mention prerequisites, when not to use, or any context for invocation beyond being 'authenticated'.

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

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

Annotations already declare readOnly=false, openWorld=true, idempotent=false, destructive=false, so the safety profile is covered. The description adds that the tool is authenticated and that retries are immediate and scoped to fanout deliveries, which is useful context, but it says nothing about side effects, interaction with cancel_queued_retries, or whether queued retries can be undone.

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

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

A single, front-loaded sentence with no filler. It is efficient, though its brevity is partially a symptom of under-specification rather than deliberate tightness.

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 non-idempotent mutation with three undocumented parameters and no output schema, the description leaves critical gaps: no parameter semantics, no guidance on retry scope or volume, and no indication of how to observe results. Annotations cover only the safety profile.

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% for three parameters (limit, windowHours, destinationId), and the description contributes no parameter meaning at all. An agent must guess what windowHours values mean, whether limit bounds the retries or the scan, and what destinationId scopes, so the description fails to compensate 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?

States a specific action (queueing immediate retries) and a specific resource (failed fanout deliveries), which an agent can distinguish from replay_event/replay_message and cancel_queued_retries. It stops short of explicitly differentiating itself from those siblings, but the verb+resource is concrete.

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

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

There is no when-to-use guidance: nothing tells the agent when to prefer retry_failed_deliveries over replay_message, replay_event, or list_retry_jobs. 'Authenticated' implies a prerequisite but no exclusions or alternatives are given.

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

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

Annotations indicate destructiveHint=true, so the agent knows it's destructive. However, the description adds no additional behavioral insights beyond 'Authenticated tool'. It does not mention that revocation is irreversible, that the key becomes immediately invalid, or any side effects like terminating active sessions. The description fails to leverage the opportunity to provide 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?

The description is extremely concise (one sentence), which is efficient but at the cost of essential information. It could include more detail without becoming verbose, so it is under-informative rather than optimally concise.

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

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

Given the tool's simplicity (one parameter, destructive, no output schema), the description should cover the parameter meaning, the irreversible nature, and the result. It fails to provide this, making it insufficient for safe and correct usage. The sibling context shows many related tools, but the description does not aid differentiation.

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 one required parameter 'apiKeyId' with no description, and schema description coverage is 0%. The description does not explain the parameter, e.g., what an API key ID is, how to obtain it, or its format. Without this information, the agent cannot correctly select or invoke the tool.

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

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

The description states the verb 'revoke' and the resource 'API key', clearly indicating the tool's action. It differentiates from sibling tools like 'create_api_key' and 'list_api_keys' which perform different operations. However, it could be more explicit about the scope (e.g., which API key is affected) and the effect (key becomes invalid).

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 (e.g., 'create_api_key', 'list_api_keys'). It only mentions 'Authenticated tool', implying authentication is required, but does not specify prerequisites or exclusions. Lack of context on when to revoke vs. other key management operations.

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 idempotentHint=false, so the safety profile is known. The description adds only 'Authenticated', but omits the operationally critical behaviors: that the previous secret is immediately invalidated, whether the new secret is returned only once, and that downstream consumers must be updated. For a destructive mutation this is a meaningful gap.

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

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

A single front-loaded sentence with no filler, which is efficient. It leans toward under-specification rather than padding, but there is no wasted text.

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

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

For a destructive, non-idempotent credential rotation with no output schema and zero parameter documentation, the description omits what the agent most needs: the effect on the old secret, the irreversibility, and how to obtain the new secret. It is insufficient for the tool's risk level.

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

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

Schema description coverage is 0%, and the description never mentions appId or endpointId, so it compensates for nothing. Neither the identifier format nor which endpoint scope the appId must match is documented anywhere.

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

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

States a specific verb ('rotating') and resource ('the signing secret for one endpoint'), which implicitly distinguishes it from the sibling rotate_source_token. It is clear but does not explicitly call out that distinction or the scope of what is affected.

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 rotate versus revoke_api_key, archive_source, or delete_endpoint, and no prerequisites for making rotation safe. The agent must infer the appropriate moment from the name alone.

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

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

Annotations already carry the safety profile (destructiveHint=true, idempotentHint=false, openWorldHint=false), so the bar is lower. The description adds two useful pieces of context: it requires authentication, and the replacement URL is returned 'once' – implying the new token cannot be retrieved again. It still doesn't state that the old token is invalidated or whether the action is reversible.

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

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

A single tight sentence with the key behavior ('rotating an ingest token') and the notable 'returned once' constraint front-loaded. No filler, though it is arguably too terse given the mutation's risk.

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

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

For a destructive, non-idempotent mutation with no output schema and an undocumented parameter, the description covers the return-once behavior and auth requirement but omits invalidation of the prior token, required permissions/scopes, and any error or rate-limit context.

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

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

The single parameter sourceId has 0% schema description coverage and the description says nothing about what sourceId refers to (a source identifier) or its format, so the agent gets only the bare name. With no schema-level documentation and no compensating text, this leaves the parameter underspecified.

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

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

States a specific verb+resource ('rotating an ingest token') and distinguishes itself from the sibling rotate_endpoint_secret by specifying 'ingest token' and the 'replacement URL' return. Clear enough for an agent to select it, though it doesn't explicitly name the alternative.

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

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

The description only says what the tool does, with no guidance on when to use it versus alternatives like rotate_endpoint_secret, nor any exclusions or preconditions (e.g., when rotation is warranted). Usage is left entirely to inference.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=false, so the safety profile is covered; the description adds the auth requirement ("Authenticated tool"), which is genuine context. However, for a destructive save with 6 optional fields, it never discloses whether omitting a field clears the existing value or what gets overwritten, which is the key behavioral unknown 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?

A single front-loaded sentence with no padding or repetition. It is efficient, though its brevity comes at the cost of the missing details noted elsewhere rather than being genuinely information-dense.

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

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

For a destructive 7-parameter mutation with no output schema and no annotation-independent detail, the description is too thin: no usage context, no parameter meaning, and no patch-vs-replace semantics. An agent would be guessing at how to invoke it safely.

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% across 7 parameters, and the description adds nothing about them — it never mentions appId, the color fields, or whether the call is a full replacement or partial update. With only "branding defaults" as a hint, the description fails to compensate for the barren 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 gives a specific verb+resource ("saving portal branding defaults") scoped to "an app", which is enough to separate it from get_portal_settings and the portal_host tools. It stops short of explicitly naming the read counterpart or clarifying that it creates-or-overwrites existing settings.

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

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

There is no when-to-use guidance, no mention of when not to use it versus get_portal_settings (the obvious read sibling) or check_portal_host, and no stated prerequisites beyond a bare "Authenticated" note. The agent must infer everything from the name.

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

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

Annotations already declare readOnly=false, openWorld=true, idempotent=false and destructive=false, so the safety profile is covered. The description adds genuine value beyond them: delivery can trigger actions at customer endpoints and 'an accepted message is not proof of delivery,' disclosing the async, side-effecting nature of the call. It does not cover auth requirements or rate limits.

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, action front-loaded, with zero filler. The prerequisite sentence and the delivery caveat each carry distinct 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 mutation tool with no output schema and six undocumented parameters, the description covers the required inputs and the async delivery caveat, which is the most important omission risk. It still leaves messageId, idempotencyKey, and the shape of the untyped payload field unexplained, which an agent needs before invoking.

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% across six parameters, so the description must compensate and only partially does: 'app, recipient, event type, and payload' loosely maps to appId, recipient, type, and the untyped data field. It says nothing about messageId or idempotencyKey, the latter being important given idempotentHint=false.

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

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

States a specific verb and resource — 'Send a webhook event from an outbound app to the specified customer' — which is clearly distinct from siblings like replay_message, retry_failed_deliveries, and replay_events. An agent can tell this is the fresh-outbound-send tool without opening any schema.

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

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

There is no when-to-use vs when-not-to-use guidance and no named alternatives, despite close siblings (replay_message, retry_failed_deliveries) where routing matters. The closest thing to guidance is a prerequisite list, which is parameter information rather than 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?

Annotations already declare readOnlyHint=false, destructiveHint=true, and idempotentHint=false, so the safety profile is provided. The description adds genuine operational context beyond those hints: "Changes can interrupt or redirect future deliveries." It still omits what specifically gets overwritten, auth/permission requirements, and reversibility, so it only partially exceeds the annotation baseline.

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

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

Two tight sentences, mutation intent front-loaded, followed by the impact warning. No filler. Slightly undermines itself by naming capabilities that aren't in the schema, which is a small precision cost rather than 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?

It states the resource and the delivery-impact warning, but for a destructive 8-param mutation with no output schema and no parameter documentation, an agent still lacks field-level and prerequisite guidance. Adequate minimum, not complete.

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

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

Schema description coverage is 0% across 8 parameters, so the description carries the full burden and does not meet it. It gestures at url, retry policy, and enabled state (and mentions two fields absent from the schema: subscriptions and signing), while omitting name, appId, endpointId, and rateLimitPerMinute entirely.

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?

Uses a specific verb ("Change") applied to a specific resource ("customer webhook endpoint") and enumerates the mutable facets: URL, subscriptions, signing, retry policy, enabled state. This is distinguishable from create_endpoint, delete_endpoint, and get_endpoint even though no sibling is named. Minor flaw: it lists "event subscriptions" and "signing settings" that do not appear in the input schema.

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

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

No explicit when-to-use guidance, no alternative named, and no exclusion criteria among the many endpoint siblings (create_endpoint, delete_endpoint, rotate_endpoint_secret). The reader must infer this is the partial-mutation tool from the name alone.

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

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

Annotations declare destructiveHint=true, openWorldHint=false and idempotentHint=false, and the description adds nothing about them. It never warns that updating an existing event type overwrites schema/description/examplePayload, nor that the call is flagged destructive — an agent would not learn the overwrite risk from the text. The neutral 'create or update' framing also sits awkwardly beside idempotentHint=false, though this is a nuance about repeat-call semantics rather than a directional contradiction with the hints.

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

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

One sentence, front-loaded with the verb and resource, zero filler. It is efficient, though the brevity is partly under-specification rather than disciplined trimming.

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

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

For a destructive, non-idempotent mutation with five undocumented parameters and no output schema, the description leaves out the things an agent most needs: what appId scopes, what the payload objects contain, and how an update mutates existing configuration. The one-liner is not enough context for this operation.

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

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

Schema description coverage is 0% across 5 parameters, so the description must carry the load — yet it only alludes to eventType and description. The required appId and the schema and examplePayload payloads are entirely unexplained, leaving an agent guessing about scope (which app) and payload format.

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

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

The description gives a specific verb pair (create or update) plus the resource (outbound event type) and its domain (customer webhook subscriptions), which separates it from list_event_types and delete_event_type. It stops short of explicitly naming the sibling it replaces or contrasting with them, but an agent can identify the operation from the text alone.

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

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

The create-or-update phrasing implies when the tool applies, but there is no statement of prerequisites, of when to prefer this over delete_event_type plus a fresh create, or of what happens if the event type already exists. Usage is inferable 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?

Annotations already declare destructiveHint=true, idempotentHint=false and readOnlyHint=false, so the safety profile is covered. The description adds only the word 'Authenticated', which hints at an auth requirement but says nothing about what an update overwrites, what happens to unspecified fields, or why an 'upsert' is flagged non-idempotent. No contradiction with annotations, but minimal added value.

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

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

A single short sentence with zero filler and the core action front-loaded. It is efficient, though the brevity reflects under-specification as much as discipline.

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

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

For a destructive, non-idempotent mutation with no output schema and no parameter documentation, the description omits the things an agent most needs: which fields are updatable, how existing data is affected, and what authentication entails. Annotations carry the safety signal, but the rest of the contract is absent.

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% across three parameters, and the description adds no meaning for appId, recipient, or name. It does not explain whether 'recipient' is an ID or an address, what 'name' labels, or how appId scopes the operation, leaving the agent to guess at all three.

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

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

The description names a specific verb pair (creating or updating) and the resource (recipient), and 'upsert' semantics are made explicit rather than left to the tool name. It does not differentiate itself from siblings like list_recipients or any other recipient-mutating operation, so it stops short of a 5.

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

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

There is no when-to-use guidance: nothing tells the agent when to upsert versus list_recipients, or whether this is the right call when a recipient may or may not already exist. No prerequisites or exclusions are stated.

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