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

With no annotations, the description carries the full behavioral burden. It does not state that this is a read-only operation, what authentication is required, how results are returned, or any rate limits. 'Over time' hints at a time series, but return format, granularity, and pagination remain undocumented.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately sized for a simple analytics retrieval 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 five-parameter analytics tool with no annotations and no output schema, the description is too sparse. It does not clarify available metrics, time-range behavior beyond the schema, or how it relates to other analytics siblings, leaving important context missing.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters. The description adds no additional parameter meaning, making the baseline score of 3 appropriate.

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

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

The description states a clear verb and resource: 'Get campaign performance analytics over time.' It is not a tautology and conveys the core action. However, it does not explicitly distinguish this tool from siblings like sends_analytics or canvas_analytics, so it falls short of a 5.

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

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

No when-to-use guidance or alternatives are given. An agent must infer that this is for campaign-level analytics rather than sends, canvas, segments, or events analytics. No exclusions or prerequisites are stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not state that this is a read-only lookup, whether it requires an existing campaign, or what the response contains. For an unannotated retrieval tool with auth parameters, this is a significant gap.

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

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

One short, front-loaded sentence with no wasted words, which is structurally sound. But the brevity reflects under-specification rather than disciplined concision, so it earns only a middling score.

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

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

With no annotations, no output schema, and no parameter commentary in the description, an agent lacks key details: read-only semantics, failure behavior for unknown campaign_id, and whether the apiKey/restEndpoint parameters are caller-supplied or preconfigured. The definition is thin for a tool in a crowded sibling set.

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

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

Schema description coverage is 100%, so campaign_id, apiKey, and restEndpoint are each documented in the schema. The description adds no format, ID-source, or auth-scoping context beyond that, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Get details for a specific campaign'), which is clear enough on its own. However, it gives no differentiation from close siblings like campaigns_list, campaigns_analytics, canvas_details, or segments_details, leaving the agent to infer boundaries from names 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?

There is no guidance on when to use this tool versus campaigns_list or campaigns_analytics, and no mention of prerequisites or required identifiers beyond the schema. The agent must infer usage entirely from the tool 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?

With no annotations, the description carries the full behavioral burden and falls short: it says 'all campaigns' but never mentions pagination (despite a 'page' parameter), that archived campaigns are excluded unless include_archived is set, or that authentication credentials are required. Nothing about rate limits or return behavior is 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?

A single short sentence with zero filler and the resource front-loaded. It is efficient, though its brevity contributes to the under-specification noted in other dimensions rather than being a model of dense 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 6-parameter list tool with no annotations and no output schema, the description is too thin. It omits pagination behavior, archiving defaults, filtering semantics, and what the response contains — all of which an agent needs to call this correctly alongside 70+ 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 description coverage is 83%, so the schema already documents page, include_archived, last_edit_time_gt, apiKey, and restEndpoint. The description adds no parameter meaning beyond that, which is the baseline expectation when the schema does the heavy lifting; only sort_direction lacks a schema description.

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

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

The description states a specific verb and resource ('List all campaigns') with clear scope ('in the workspace'), so an agent immediately knows the operation. However, it does nothing to distinguish itself from closely related siblings such as campaigns_details, campaigns_analytics, or canvas_list, leaving the agent to infer which is appropriate.

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

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

There is no guidance on when to use this tool versus alternatives like campaigns_details (a single campaign) or campaigns_analytics (metrics). No prerequisites, no mention of the required API key/endpoint parameters, and no 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?

No annotations are provided, so the description carries the full behavioral burden. It implies creation of a schedule but says nothing about required auth (apiKey/endpoint), whether re-scheduling an existing campaign overwrites prior schedules, whether the campaign must already be API-triggered, or failure behavior.

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

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

A single front-loaded sentence with no filler, which is well-structured. However, the extreme brevity leaves the complexity of an 8-parameter tool unaddressed.

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

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

For a tool with 8 params, nested objects, low schema coverage, no output schema and no annotations, one sentence is clearly insufficient. Nothing about prerequisites, side effects or required campaign state is conveyed.

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

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

Schema description coverage is only 38% across 8 parameters including nested audience, recipients and schedule objects, and the description adds zero parameter meaning. The undocumented params (send_id, broadcast, audience, recipients) are left entirely to the agent to guess.

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

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

States a specific verb ('Schedule'), resource ('API-triggered campaign') and scope ('for future delivery'). The 'API-triggered' qualifier usefully distinguishes it from a general campaign scheduler, but it does not explicitly name sibling alternatives like messages_schedule_create or campaigns_schedule_update, so the differentiation is implicit.

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 statement of when to use this versus campaigns_trigger_send (immediate send) or the update/delete schedule variants. An agent must infer from the name alone that this creates a new schedule rather than modifying one.

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

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

No annotations are supplied, so the description carries the full behavioral burden, and it discloses almost nothing. It does not confirm the operation is destructive/irreversible, whether it cancels or merely detaches the schedule, what permissions are required, or what happens if the schedule_id is invalid. The 'API-triggered' qualifier is the only added behavioral 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?

A single front-loaded sentence with zero waste. It is efficient, though so terse that it borders on under-specification for a destructive 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 destructive mutation with no annotations and no output schema, the definition is too thin. It omits confirmation of what gets destroyed, authorization requirements, and any post-delete state an agent would need to reason about before calling it.

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

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

Schema coverage is 100%, so the two required IDs and the auth/endpoint parameters are already documented in the schema; this sets the baseline at 3. The description adds no syntax, format, or sourcing detail beyond what the schema states.

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

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

States a specific verb ('Delete') and resource ('scheduled API-triggered campaign'), which cleanly separates it from campaigns_schedule_create and campaigns_schedule_update. It does not explicitly name the near-identical siblings canvas_schedule_delete or messages_schedule_delete, but the resource qualifier 'campaign' makes the scope inferable.

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 alternatives, no prerequisites (e.g., the campaign must have an existing API-triggered schedule), and no exclusions. The agent must infer everything from the tool 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?

No annotations are provided, so the description carries the full behavioral burden. 'Update' implies a mutation, but nothing is said about required permissions, whether the update is idempotent or reversible, how it interacts with an existing schedule, or what happens on failure. For a mutation endpoint with zero annotation coverage, this is a significant gap.

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

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

One sentence with no wasted words and the action front-loaded, which is efficient. But for a five-parameter tool with a nested schedule object, the description is undersized rather than appropriately sized.

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

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

This is a mutation tool with no annotations, no output schema, and a nested object parameter set. The description supplies none of the missing context (preconditions, mutation semantics, effect on the existing schedule), leaving an agent without 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 80%, so the schema already documents campaign_id, schedule_id, and the nested schedule fields (time, in_local_time, at_optimal_time). The description adds nothing beyond that baseline, which is the expected 3 when the schema does the heavy lifting.

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

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

The description gives a clear verb (Update) and resource (scheduled API-triggered campaign), and the 'API-triggered' qualifier narrows the campaign type. However, it does nothing to distinguish this from siblings like campaigns_schedule_create, campaigns_schedule_delete, or canvas_schedule_update, so an agent still has to infer which schedule operation to pick from the name alone.

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

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

There is no guidance on when to use this versus creating or deleting a schedule, no prerequisite or precondition, and no mention of alternatives. The agent is left to infer usage entirely.

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

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

No annotations are supplied, so the description carries the full behavioral burden and fails to. It does not state that this is a live send (irreversible), whether send_id deduplicates or provides idempotency, auth requirements beyond the apiKey field, rate limits, or what a successful response contains.

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

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

Two tight sentences, purpose front-loaded ahead of the prerequisite, with no filler. It is efficient, though the sparseness is a coverage problem rather than a conciseness virtue.

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

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

For an 8-parameter send tool with nested audience/recipients objects, zero annotations, and no output schema, the description is insufficient. An agent gets no guidance on the audience/recipients/broadcast interaction, recipient dedup via send_id, or what constitutes success.

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 75%, so the schema documents most parameters (apiKey, send_id, campaign_id, restEndpoint, recipients, trigger_properties) while broadcast and audience are bare. The description adds no meaning beyond the schema — notably it never explains audience vs recipients or broadcast semantics — so the baseline 3 stands.

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 (Trigger) and resource (API-triggered campaign) and names Braze as the system. It does not differentiate itself from near-siblings like canvas_trigger_send or messages_send, so an agent must infer the distinction from the name alone.

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

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

Provides one real prerequisite — the campaign must be pre-configured as API-triggered — which is genuinely actionable. It says nothing about when to prefer this over canvas_trigger_send, messages_send, or campaigns_schedule_create, so alternative-selection is left to inference.

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

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

With no annotations provided, the description carries the full behavioral burden. It implies a time-series read via 'over time' but says nothing about required authentication (apiKey/restEndpoint), the maximum allowed length, rate limits, whether results are paginated, or what happens if the Canvas ID is invalid.

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 redundancy. It is economical, though its brevity is also the source of its incompleteness rather than a sign of tight 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 read tool with 7 parameters, no annotations, no output schema, and 57% schema coverage, the description is far too thin. It lacks any explanation of the step/variant breakdown options, the time-range semantics, or the response shape an agent needs to interpret results.

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

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

Schema coverage is only 57%, and the description adds no parameter detail beyond the vague 'over time' hint. The three undocumented parameters (ending_at, include_step_breakdown, include_variant_breakdown) are neither explained in the schema nor in the description, leaving meaningful gaps.

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

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

The description names a specific verb (Get) and resource (Canvas performance analytics) and adds a temporal scope ('over time'), which distinguishes it from canvas_details and canvas_summary. However, it does not explicitly differentiate itself from the near-identical campaigns_analytics or sends_analytics siblings, 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 guidance on when to use this tool versus canvas_summary, canvas_details, or campaigns_analytics, nor any mention of prerequisites such as a required Canvas ID or time window. The agent must infer usage entirely 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?

No annotations are provided, so the description carries the full burden. It does not disclose whether this is a read-only operation, any rate limits, authentication requirements (beyond the apiKey parameter), or what the return format looks like. For a detail-fetch tool with zero annotation coverage, this is a significant gap.

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

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

A single, front-loaded sentence with no wasted words. It efficiently conveys the core purpose.

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

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

With no annotations and no output schema, the description should do more to explain behavioral aspects like read-only nature, authentication, and return details. The minimal description leaves the agent with insufficient context for correct invocation.

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

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

Schema description coverage is 100%: all three parameters (apiKey, canvas_id, restEndpoint) are documented in the schema. The description adds no parameter information beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

States a specific verb (Get) and resource (details for a specific Canvas), and names the identifier. It is differentiable from siblings like canvas_list or canvas_summary by the word 'specific', though it does not explicitly contrast with canvas_summary which could also return details.

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

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

No guidance on when to use this versus alternatives like canvas_summary, canvas_analytics, or canvas_list. The agent must infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It doesn't disclose pagination behavior, authentication requirements (apiKey/restEndpoint), or whether the list is filtered by default (e.g., include_archived). For a list tool with 6 parameters and no annotations, this is a significant gap.

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

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

The description is a single, clear sentence that is front-loaded with the essential action. It contains no unnecessary words.

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

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

Given the complexity (6 parameters, no output schema, no annotations) and low schema description coverage, the description is incomplete. It fails to explain pagination, filtering options, or authentication, which are crucial for correct invocation.

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

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

Schema description coverage is 33% (only apiKey and restEndpoint are described). The description adds no meaning for the other parameters (page, sort_direction, include_archived, last_edit_time_gt), leaving them undocumented. A baseline of 3 is not warranted because the description does not compensate for the low coverage.

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

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

The description states a clear verb ('List') and resource ('Canvases in the workspace'), which is easily distinguishable from siblings like canvas_details or canvas_analytics. However, it lacks explicit differentiation from campaigns_list (a similar list tool for a different resource).

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

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

There is no guidance on when to use this tool versus alternatives like canvas_details or campaigns_list. The description only states what it does, not when to use it or any prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It contributes only the fact that the Canvas must be API-triggered; it says nothing about required API key/permissions, idempotency, behavior when a schedule already exists, or reversibility. For a scheduling mutation with zero annotation coverage this is thin.

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 the verb and resource first and no filler. It is efficient, though the brevity is partly under-specification rather than tight 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?

With 7 parameters, nested objects, 43% schema coverage, no annotations, and no output schema, the description should do meaningful work but does not. An agent cannot determine prerequisites (API-triggered Canvas, auth), scheduling conflict behavior, or parameter usage from it.

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

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

Schema description coverage is only 43% across 7 parameters, including nested audience, recipients, and schedule objects, so the burden falls on the description. The description explains none of them — it does not clarify broadcast vs recipients, the schedule.time format, or how canvas_id relates to 'API-triggered'.

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 ('Schedule an API-triggered Canvas') plus the outcome ('future delivery'), which implicitly separates it from the immediate-send canvas_trigger_send and from canvas_schedule_update/delete siblings. It does not name any sibling explicitly, 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 explicit when-to-use guidance. The phrase 'for future delivery' hints that this is the deferred counterpart to canvas_trigger_send, but the agent is left to infer that routing, and nothing states prerequisites or when to prefer update vs create.

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

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

No annotations are provided, so the description carries the full burden. It says 'Delete' but never states that the schedule is removed while the Canvas itself survives, that the deletion is irreversible, or whether special permissions/API key scopes are required. For a destructive operation with zero annotation coverage 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 short sentence with the action front-loaded and no filler. It is efficient, though its brevity borders on under-specification for a destructive tool rather than being an example of well-packed conciseness.

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

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

For a destructive, two-required-parameter tool with no annotations and no output schema, the description omits critical context: scope of destruction (schedule only vs. Canvas), irreversibility, and auth/permission expectations. An agent could call it correctly, but would do so without knowing the consequences.

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

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

Schema description coverage is 100% (canvas_id, schedule_id, apiKey, restEndpoint all documented), so the baseline is 3. The description adds nothing about parameter meaning beyond what the schema already spells out.

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 (Delete) and resource (a scheduled API-triggered Canvas), and the resource name distinguishes it from the sibling campaigns_schedule_delete and messages_schedule_delete. It does not explicitly name those siblings, but the resource specificity makes selection unambiguous.

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

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

No when-to-use guidance, no prerequisites, and no mention of the sibling alternatives (campaigns_schedule_delete, messages_schedule_delete) or of canvas_schedule_update as a non-destructive path. The agent must infer usage entirely 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?

No annotations, so the description carries the full behavioral burden. It does not disclose permissions, side effects, reversibility, rate limits, or response behavior for a mutation tool; only the word 'Update' implies a write.

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 front-loaded sentence with no filler. It is appropriately concise, though sparse; missing detail is 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?

Mutation tool with no annotations, no output schema, nested object, and five parameters needs more context. The description leaves usage, behavior, and return expectations unspecified.

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

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

Schema description coverage is 80%, so baseline is 3. The description adds no parameter meaning beyond the schema; nested schedule fields are documented in the schema, not the 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?

Clear verb 'Update' and resource 'scheduled API-triggered Canvas', which separates it from create/delete and campaign/message siblings. It does not explicitly name or contrast with alternatives, so sibling differentiation is implicit rather than stated.

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

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

No when-to-use, prerequisites, or alternatives are given. The agent must infer that this is for modifying an existing Canvas schedule rather than creating or deleting one.

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

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

No annotations are provided, so the description carries the full burden. It implies a read operation with 'Get', but does not disclose required permissions, behavior of the length/ending_at parameters, rate limits, or what the summary contains.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately concise, though its brevity leaves the specification thin.

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

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

For a 5-parameter analytics tool with no annotations and no output schema, the description is incomplete. It does not explain the required time-range parameters, the meaning of 'summary', or how this differs from related analytics tools.

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

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

Schema description coverage is 80%, so the schema already documents most parameters. The description adds no meaning beyond the schema, which is acceptable at this coverage level but not helpful.

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

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

The verb 'Get' and resource 'Canvas' are clear, but 'summary analytics' is vague and does not distinguish this tool from sibling canvas_analytics. An agent cannot tell from the description alone which Canvas analytics tool to choose.

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

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

The description provides no guidance on when to use this tool versus canvas_analytics, canvas_details, or campaigns_analytics. It offers no prerequisites, exclusions, or context for selecting it.

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

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

With no annotations provided, the description carries the full behavioral burden, and it discloses only the API-triggered precondition. It says nothing about whether the send is immediate, how broadcast versus recipients interact, whether recipient lists are deduplicated, rate limits, or authentication requirements beyond the presence of an apiKey parameter.

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, zero filler, and the operative precondition is front-loaded rather than buried. Nothing in the text needs to be removed.

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, no-annotation, no-output-schema trigger tool, the description is significantly under-specified. An agent can identify the operation but lacks the information needed to construct a correct payload for broadcast or audience-based sends.

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

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

Schema description coverage is only 57% across 7 parameters with nested objects, so the description needs to compensate and does not. Non-obvious parameters such as broadcast, audience, send_to_existing_only, and the top-level versus per-recipient canvas_entry_properties distinction are left entirely undocumented here.

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

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

The description gives a specific verb ('Trigger') and resource ('Canvas'), so the agent knows exactly what operation it performs. It does not explicitly distinguish itself from the near-identical sibling campaigns_trigger_send or from messages_send, but the Canvas-versus-Campaign distinction is inherent in the name.

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

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

It states one important precondition -- the Canvas must already be configured as API-triggered in Braze -- which implies when this tool is applicable. However, it offers no guidance on when to prefer this over campaigns_trigger_send, messages_send, or the canvas_schedule_* family.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether creation is idempotent or upserts on an existing item_id, what happens on a duplicate ID, what permissions/API key scope are needed, or how many requests/rate limits apply. Only the bare fact of mutation is conveyed.

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 is arguably too terse for a five-parameter mutation tool with a nested payload, but nothing in it 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 mutation tool with no annotations, no output schema, and a free-form nested item_data object, the description should cover at least auth prerequisites, the batch-vs-single choice, and what is returned on success. None of that is present.

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

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

Schema description coverage is 100%, so the parameters are documented in the schema and a baseline of 3 applies. The description adds no meaning beyond the schema, and notably says nothing about the structure of the free-form item_data object or the required catalog_name/item_id pairing.

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 (catalog item), and the qualifier 'a single' hints at scope versus a bulk operation. However, it never names the competing sibling catalog_items_create, so the distinction between single-item and batch creation must be inferred.

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 indication of when to use this tool rather than catalog_items_create (bulk), catalog_item_update, or catalog_item_edit. No prerequisites are mentioned, even though the schema requires an apiKey and restEndpoint.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Delete' implies a destructive mutation, but the description does not state irreversibility, permission requirements, side effects, or authentication needs. This is a significant gap for a destructive tool with zero annotation coverage.

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

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

A single efficient sentence with no waste. It is front-loaded and to the point, though it is perhaps too terse to be fully helpful.

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

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

For a destructive tool with no annotations, no output schema, and no supplementary behavioral context, the description is too sparse. An agent needs to know if the operation is reversible, what permissions are required, and how it relates to sibling deletion tools. None of that is present.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters (apiKey, item_id, catalog_name, restEndpoint) with clear descriptions. The description adds nothing beyond what the schema provides. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

States a specific verb (Delete) and resource (catalog item) with scope limited to a single item. However, with sibling tools like catalogs_delete, catalog_items_delete, and catalog_item_edit present, the description does not differentiate exactly how this differs from those similarly-named alternatives besides the singular 'item'.

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

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

No explicit guidance on when to use this tool versus alternatives. There are two other deletion tools (catalogs_delete, catalog_items_delete) and it doesn't state the conditions or prerequisites for choosing this one.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Partial update' hints at merge semantics but says nothing about permissions/auth (only the apiKey param hints at this), whether changes are reversible, what happens to omitted fields, or any 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?

A single short sentence that is front-loaded with the core verb and resource. It is efficient, though arguably under-specified 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?

For a mutation tool with no annotations, no output schema, a nested free-form item_data object, and several confusingly similar siblings, this one-line description leaves far too much unspecified for an agent to call 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 100% and every parameter (apiKey, item_id, item_data, catalog_name, restEndpoint) is documented in the schema. The description adds no syntax or format detail beyond that, so the baseline of 3 applies.

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

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

States a clear verb+resource ('Edit a single catalog item') and adds scope via '(partial update)'. However, the sibling set contains catalog_items_edit, catalog_item_update, catalog_items_update and catalog_items_create, and the description offers no way to distinguish catalog_item_edit from these near-identical tools.

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

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

There is no when-to-use guidance and no mention of alternatives, which is a real gap given several sibling tools appear to perform overlapping edits/updates. The agent must guess between catalog_item_edit, catalog_items_edit and catalog_item_update.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read operation, but does not disclose authentication requirements, rate limits, error behavior (e.g., missing item), or return characteristics. For a tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single front-loaded sentence with no wasted words. It states the core action and scope efficiently.

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

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

For a simple retrieval tool with full schema coverage and no output schema, the description covers the basic purpose. However, given no annotations, it omits behavioral context such as that it is a read-only operation and what the response contains, leaving the agent with only minimal 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?

Schema description coverage is 100%, so the schema already documents all four parameters (including apiKey, item_id, catalog_name, restEndpoint). The description's phrase 'by ID' aligns with item_id but adds no syntax, format, or conditional detail beyond what the schema provides; baseline 3 is appropriate.

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

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

The description states a specific verb ('Get'), resource ('catalog item'), and scope ('single ... by ID'), which distinguishes it from the sibling list tool catalog_items_list. However, it does not explicitly name the sibling or contrast them, so it falls short of the clearest possible differentiation.

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

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

The description gives no explicit when-to-use guidance, prerequisites, or alternatives. It implies retrieval by ID but does not say when to choose this over catalog_items_list or catalog_items_create, leaving the agent to infer the context entirely.

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

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

No annotations are provided, so the description carries the full burden, yet it discloses nothing about mutation behavior: whether duplicate IDs error or upsert, whether the write is atomic across the batch, permission/API-key requirements, or rate limits. For a bulk mutation endpoint this is a substantial 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 zero filler and no redundancy. It is efficient, though its brevity is partly under-specification rather than 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 bulk write tool with no annotations and no output schema, the description omits critical context: duplicate-ID handling, partial-failure semantics, and the 50-item cap's implications. An agent could invoke it but cannot predict its failure modes.

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

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

Schema description coverage is 100%, so all four parameters (items, apiKey, catalog_name, restEndpoint) are already documented in the schema. The description adds only the notion of batching, matching the baseline 3 when the schema does the heavy lifting.

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

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

The description gives a clear verb+resource ('Create ... items in a catalog') and the word 'multiple' implicitly separates it from the singular sibling catalog_item_create. It never names or contrasts siblings explicitly, 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?

Usage is only implied through the word 'multiple' — an agent can infer batch creation, but the description never states when to use this batch tool versus catalog_item_create / catalog_items_update / catalog_items_edit, nor any prerequisites.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about irreversibility, whether deletion is permanent, failure behavior for partial batches, or auth requirements. For a destructive batch operation this is a significant gap.

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

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

A single front-loaded sentence with zero filler. Nothing is repeated and the scope qualifier ('multiple') comes before the resource.

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

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

With no annotations, no output schema, and a destructive batch semantic, the description should disclose irreversibility and batch-failure behavior. Parameter documentation is fully handled by the schema, but the behavioral side is left entirely unaddressed.

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

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

Schema description coverage is 100%, so all four parameters including the items array and its max-50 constraint are already documented. The description adds no format or syntax detail beyond the schema, making the baseline 3 appropriate.

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

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

States a specific verb (Delete) plus resource (items in a catalog) and scope (multiple). An agent can distinguish it from the singular catalog_item_delete and catalogs_delete without opening schemas, though it never names 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?

No guidance on when to use this batch delete versus catalog_item_delete, nor any prerequisites such as API key scope or endpoint selection. The only usage constraint (max 50 items) lives in the schema, not the description.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose that updates are partial, but omits permission/auth requirements, batching failure behavior, rate limits, and whether unspecified fields are preserved or cleared.

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 borders on under-specification rather than true conciseness.

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

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

For a batch mutation tool with no annotations and no output schema, the one-line description is too thin: it doesn't clarify merge-vs-replace semantics for partial updates, per-item error behavior, or how it relates to sibling edit/update tools.

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

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

Schema description coverage is 100%, so the schema already documents catalog_name, items, apiKey, and restEndpoint. The description adds only the notion of multiple items and partial updates, which aligns with but does not extend 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+resource ('Edit ... items in a catalog') and signals batch scope with 'multiple items', which distinguishes it from the singular catalog_item_edit sibling. However, it does not explain how it differs from the near-identical catalog_items_update sibling.

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

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

No when-to-use guidance is given. With siblings like catalog_item_edit and catalog_items_update that overlap heavily, the agent gets no criterion for choosing this tool over them, and no prerequisites or preconditions are stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. The word 'List' implies a read-only operation, but the description does not disclose pagination behavior despite a cursor parameter, nor does it mention authentication, rate limits, or return characteristics.

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

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

The single sentence is front-loaded and free of filler, which is structurally appropriate. However, it is so sparse that it omits useful context rather than earning its brevity through complete coverage.

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

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

For a simple list tool with complete schema coverage and no output schema, the description is minimally adequate. It omits pagination context and sibling differentiation, but the schema covers the parameters well enough to make the tool callable.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema. The description adds no additional parameter-level meaning beyond 'items in a catalog', making the baseline 3 appropriate.

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

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

The description states a specific verb and resource ('List items in a catalog'), so an agent can tell it is a read operation on catalog items. It does not explicitly distinguish itself from siblings such as catalogs_list or catalog_item_get, which prevents 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 guidance on when to use this tool versus alternatives like catalog_item_get or catalogs_list. The one-line description only implies usage from the name and resource.

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

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

With no annotations, the description carries the full burden, and it does disclose one genuinely important trait: the operation replaces the entire item, so unspecified fields are overwritten. It says nothing about auth requirements (the apiKey/restEndpoint params), error behavior, or the 50-item batch limit beyond what the schema already states.

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

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

A single tight sentence with the replacement constraint front-loaded in the parenthetical. No 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 mutation tool with no annotations and no output schema, the description is thin: it omits auth prerequisite context for the apiKey/restEndpoint parameters and gives no sense of outcome or failure modes. It communicates the bare minimum needed to recognize the 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 100%, so the schema already documents all four parameters including the max-50 items constraint and the id field. The description's 'multiple items' phrasing adds no syntax or format detail beyond the schema, making 3 the appropriate baseline.

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

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

States a specific verb (update) and resource (multiple items in a catalog), and the parenthetical '(replaces entire item)' pins down the semantics that distinguish it from a partial-update sibling. It stops short of naming catalog_items_edit as the contrasting alternative, so differentiation is implied rather than explicit.

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 or when-not-to-use guidance. The '(replaces entire item)' note hints at the replace-vs-merge distinction, but the description never tells the agent to prefer catalog_items_edit for partial updates, which is the key routing decision among the many catalog siblings.

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

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

With no annotations, the description carries the full burden. It does disclose one important behavioral trait — the operation replaces the entire item rather than patching it, implying omitted fields are dropped — but says nothing about required permissions, reversibility, or how the API key/endpoint affect the call.

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

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

A single front-loaded sentence with zero waste; the distinguishing qualifier and the replacement semantics are packed into the most valuable position.

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

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

For a mutation tool with no annotations, no output schema, and a nested required object, the description is thin: it conveys the full-replace semantics but omits nothing about behavioral consequences of dropping fields, auth requirements, or the response. Adequate but with clear gaps given the tool's 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 100%, so every parameter is already documented in the schema and the baseline is 3. The description adds no additional parameter meaning (e.g., what item_data must contain or how the nested object is treated), so it neither compensates nor detracts.

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 (Update) and resource (a single catalog item), and the qualifier 'single' distinguishes it from the plural batch sibling catalog_items_update. The parenthetical '(replaces entire item)' further hints at the update-vs-edit distinction. It stops short of naming the edit/update siblings explicitly, so it is clear but not fully differentiated.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no named alternative. The '(replaces entire item)' note implicitly signals when to prefer this over a partial-edit sibling, but the agent must infer that from the parenthetical rather than from any stated rule.

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

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

With no annotations, the description carries the full behavioral burden and falls short. It does not state that this is a mutating/write operation, that an API key is required for auth, what happens on duplicate catalog names, or whether the change 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 front-loaded sentence with zero waste. It is appropriately terse, though the terseness borders on under-specification rather than true efficiency.

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

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

For a mutating tool with no annotations and no output schema, the description is too thin: it omits auth requirements, idempotency/duplicate behavior, and any hint of what a catalog or its required fields represent.

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

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

Schema description coverage is 100%, so all three parameters (apiKey, catalogs, restEndpoint) are already documented in the schema. The description adds no syntax, format, or field-level meaning beyond it, so the baseline 3 applies.

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

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

States a specific verb (Create) and resource (catalog), so the operation is unambiguous. However, it offers no differentiation from siblings like catalogs_delete or catalogs_list beyond the verb embedded in the name itself.

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 catalog_items_create or how this relates to other catalog operations. The agent gets no routing help.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says it deletes 'all its items' – a cascading destructive effect – but does not state irreversibility, required permissions, or side effects on dependent resources. After the deletion, dependent catalogs items or references may break, and this is not disclosed. The description is minimal for a destructive 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?

One short sentence that is front-loaded with the verb and resource, and efficiently states the cascading scope. There is zero waste or filler.

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

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

For a destructive operation with no annotations and no output schema, the description is far too thin. It omits any warning about irrevocability, permission requirements, or downstream effects, and gives no guidance on when this should be used versus deleting individual items. An agent could easily misuse this tool without additional context.

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

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

Schema description coverage is 100%, so each parameter (apiKey, catalog_name, restEndpoint) is already documented in the schema. The description adds no parameter detail beyond what's in the schema. Baseline 3 is correct when the schema does the heavy lifting and the description provides no extra parameter semantics.

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

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

The description states a specific verb ('Delete') and resource ('catalog') and clarifies scope ('and all its items'). It distinguishes itself from item-level siblings like catalog_items_delete and catalog_item_delete by operating on the catalog itself. It doesn't claim catalog-only vs. sibling nuances beyond that, but the verb+resource is unambiguous.

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

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

No guidance on when to use this tool versus alternatives is given. It doesn't explain the destructive, cascading nature of the deletion, nor does it clarify prerequisites (e.g., whether the catalog must be empty or have no items). An agent has no indication of when this is appropriate versus editing items individually.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'List all' implies a read-only, unfiltered operation, but there is no mention of pagination, result limits, permissions required, or whether catalogs are returned in any order. For a no-annotation tool this is a substantial 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 short sentence with the resource front-loaded and no wasted words. It is perhaps too terse given the missing behavioral context, but structurally it is clean.

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

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

For a simple read-only list tool with no output schema, the description covers the core purpose but omits return shape hints, pagination behavior, and any auth context beyond the schema parameters. Adequate but with clear gaps.

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

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

Both parameters (apiKey, restEndpoint) already carry schema descriptions at 100% coverage, so the schema does the heavy lifting. The description adds nothing about them, which is the expected baseline when coverage is high.

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 (List) plus resource (catalogs) and scope (in the workspace). This clearly separates it from catalogs_create, catalogs_delete, and catalog_items_list. It does not name any sibling explicitly, though none is close enough to require 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?

No guidance on when to use this versus catalog_items_list or catalogs_create, and no prerequisites for when listing catalogs is the right call. The agent must infer usage entirely 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: no permission/auth requirements, no default state, no idempotency, no validation or failure behavior for a write 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 front-loaded sentence with zero padding. It is efficient, though its brevity reflects under-specification rather than disciplined concision.

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

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

For a 7-parameter mutation tool with no annotations and no output schema, the description is far too thin: it omits auth context, defaults, and any hint of what a successful create returns.

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

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

Schema description coverage is 100% with 7 documented parameters including two enums, so the schema already explains each field. The description adds no parameter meaning beyond the schema, which is the baseline 3 case.

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 a new content block'), which is enough to tell it apart from content_blocks_list, content_blocks_info and content_blocks_update by verb alone, though it never names those siblings or scopes what a content block is.

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 create versus update or list, no prerequisites, and no mention of the required apiKey/restEndpoint context. The agent must infer usage entirely 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?

No annotations are provided, so the description carries the full disclosure burden. 'Get' implies a safe read, but nothing is said about authentication (the apiKey/restEndpoint params hint at it), rate limits, or what include_inclusion_data actually returns. This is thin for a tool with zero annotation coverage.

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

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

A single front-loaded sentence with no filler, which is efficient. However, its brevity reflects under-specification rather than tight targeting of exactly what the agent 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?

The tool has 4 parameters, no output schema, and no annotations, so the description must do more work. It never explains the return shape or the optional include_inclusion_data enrichment, leaving an agent without needed context for calling it correctly.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema, and the baseline is 3. The description adds nothing about the meaning or effect of content_block_id or include_inclusion_data, so it does not exceed the baseline.

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

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

The description states a specific verb ('Get details') and resource ('a specific content block'), which clearly identifies it as a single-item read. It does not distinguish itself from siblings like content_blocks_list or content_blocks_update beyond the name, 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 guidance on when to use this tool versus alternatives such as content_blocks_list or content_blocks_info's siblings, and no stated prerequisites. The agent must infer that this is the single-block counterpart to the list tool.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about read-only safety, pagination behavior, or the fact that results can be narrowed. 'List all' also obscures that the operation supports date filtering, which is the only behavioral hint available and it is absent.

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 and free of waste. It is arguably under-specified rather than padded, so it does not lose points for verbosity.

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

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

For a 6-parameter tool with no annotations and no output schema, the description is too thin: it does not explain the filtering capability surfaced by the schema, the pagination model, or the return shape, leaving the agent to infer behavior from field names alone.

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 high (83%), so the schema already documents limit, modified_after, modified_before, and the auth fields; the baseline of 3 applies. The description adds nothing about the filter semantics, and its phrase 'all content blocks' slightly tensions with the available modified_after/before filters.

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 ('content blocks') scoped to the workspace, so an agent can identify it as the read/list operation. However, it offers no explicit differentiation from the close siblings content_blocks_info, content_blocks_create, and content_blocks_update beyond the plain verb.

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

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

There is no guidance about when to use this list operation versus content_blocks_info or the create/update siblings, and no mention of prerequisites such as credentials. Usage is only implied by the tool 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?

No annotations are provided, so the description carries the full behavioral burden. It says only that an existing block is updated, but does not disclose whether this is a partial or full replacement, what permissions or authentication are required, whether changes are reversible, or what side effects occur. It conveys mutation but no meaningful 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 a single, front-loaded sentence with no wasted words. It is appropriately sized for what it attempts to convey, even though it is under-specified 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?

Given a mutation tool with 7 parameters, no annotations, no output schema, and no usage guidance, the description is far too thin. An agent lacks essential context about authentication requirements, update semantics, and consequences, making this definition inadequate for safe invocation.

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

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

Schema coverage is 100%, so all 7 parameters (including content_block_id, name, tags, state, apiKey, content, restEndpoint) are documented in the schema. The description adds no additional parameter meaning, which is the baseline when the schema already does the heavy lifting.

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

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

The description states a specific verb ('Update') and resource ('content block'), making the core action unambiguous. However, it does not differentiate this tool from siblings like content_blocks_create, content_blocks_info, or content_blocks_list, so an agent gets no routing help beyond the verb.

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

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

There is no indication of when to use this tool versus alternatives, no prerequisites (such as needing an existing content block ID or API credentials), and no exclusions. The description offers no usage guidance at all.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses deprecation status (a non-obvious behavioral trait), but says nothing about authentication expectations, whether re-adding an existing address is idempotent, or how many addresses can be submitted at once, leaving real gaps for a mutation tool.

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

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

Two short clauses with zero waste, and the most decision-relevant information (the deprecation redirect) is front-loaded before the purpose statement.

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 three-parameter mutation with full schema coverage and no output schema, the description covers purpose and lifecycle status adequately. It is not rich on operational behavior, but nothing essential to calling it correctly is missing.

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

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

Schema description coverage is 100%, so all three parameters (email, apiKey, restEndpoint) are already documented in the schema. The description only implies that the target is an email list and adds no format, limit, or auth detail beyond the structured fields — baseline 3 applies.

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

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

States a specific verb and resource ('Add email addresses to the blacklist') and immediately flags itself as deprecated in favor of the sibling tool email_blocklist, so an agent can distinguish it from the near-identically named alternative without opening the schema.

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

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

Explicitly names the condition that should select another tool: '[DEPRECATED: Use email_blocklist]'. This is a direct when-not-to-use statement with a named alternative, which is the strongest form of routing guidance.

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

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

With no annotations, the description carries the full burden. It usefully discloses the consequence of blocking (no messages delivered) and "Add" implies an additive, persistent mutation, but it says nothing about reversibility, permissions, or whether re-adding an existing address is idempotent.

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, front-loaded with the action and followed by the effect. Efficient, though the second sentence borders on restating what "blocklist" already implies.

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

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

For a mutation tool with no annotations and no output schema, the description covers the core action and its effect but omits auth requirements (implied only by the apiKey param), response behavior, and how it relates to email_blacklist. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, including the "max 50" limit, so the schema already documents all three parameters. The description adds no syntax, format, or batching detail beyond what the schema provides, making the baseline 3 appropriate.

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

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

States a specific verb ("Add") and resource ("email addresses to the blocklist"), so the action is unambiguous. However, it does not distinguish itself from the near-identical sibling email_blacklist, leaving an agent to guess which one to pick.

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 prerequisites, and no mention of alternatives despite a confusingly similar sibling (email_blacklist). "Blocked emails will not receive any messages" describes an effect, not a usage condition.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It states a destructive removal but not the consequences: whether the removal is reversible, whether it re-enables sending to previously bounced addresses, whose permission is required, or whether it is rate limited.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though its brevity is also the source of the missing behavioral detail rather than an asset.

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 zero annotation coverage and no output schema, the description is too thin. It omits prerequisites, reversibility, error behavior, and the choice between the single-email and multi-email modes, leaving the agent to infer behavior from parameter names alone.

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

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

Schema description coverage is 100%, so the parameters (email, emails with max 50, apiKey, restEndpoint) are already fully documented in the schema. The description adds nothing beyond that, so the baseline 3 applies.

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

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

The description gives a specific verb (Remove) plus resource (email addresses) and target scope (hard bounce list), which is easily distinguished from close siblings like email_spam_remove and email_blocklist. It does not, however, explicitly name or contrast those siblings.

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

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

No when-to-use or when-not-to-use guidance is given. The description never states prerequisites (Braze REST API key and endpoint are required by the schema) or when an agent should prefer this over email_hard_bounces (inspection) or email_blocklist.

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

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

No annotations are provided, so the description carries the full burden. 'Query' implies a read, but it says nothing about auth requirements (the apiKey/restEndpoint params hint at this), pagination behavior, or what the response contains.

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

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

A single front-loaded sentence with no redundant phrasing. It is efficient, though its brevity leaves information gaps that conciseness alone cannot excuse.

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 reporting tool with full schema coverage and no output schema, the description is minimally adequate but omits return-shape and pagination expectations that an agent would need to drive repeated calls.

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

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

Schema description coverage is 100% with all seven parameters documented inline, including the limit cap and date format. The description adds no meaning beyond what the schema already provides, so the baseline 3 applies.

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

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

States a specific verb (query) and a precise resource (emails that hard bounced) with a date-range scope. It distinguishes itself from the create/remove-oriented email siblings, though it doesn't name which neighbor it replaces.

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

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

No guidance on when to use this versus alternatives such as email_bounce_remove or email_unsubscribes, and no prerequisites or context about acceptable date ranges. The agent must infer the call site.

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

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

No annotations are provided, so the description carries the full burden. It says 'Remove' but does not state that this is a mutating/destructive operation, whether it requires authentication, whether removal is idempotent, or what happens if an address is not on the list.

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 extreme brevity is part of why substance is missing elsewhere rather than a virtue in itself.

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

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

This is a mutation tool with no annotations, no output schema and both single and batch parameter forms. The description does not explain the single-vs-batch choice, auth requirements, or any confirmation/limit behavior, so it is thin for the complexity involved.

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

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

Schema description coverage is 100%, so the schema already documents email, emails (max 50), apiKey and restEndpoint. The description adds no syntax, format or batching guidance beyond that, so the baseline of 3 applies.

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

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

The description gives a specific verb ('Remove') and resource ('email addresses from the spam list'), which is better than a tautology. However, the sibling list contains several near-identical removal tools (email_bounce_remove, email_blacklist, email_blocklist, sms_invalid_phones_remove), and the description does nothing to distinguish the spam list from a blocklist or blacklist, leaving real ambiguity.

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

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

There is no guidance on when to use this tool versus the adjacent suppression-list tools, nor any prerequisite note. The agent must infer usage entirely 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?

No annotations are provided, so the description carries the full behavioral burden, and it says only that it changes state. It omits whether the change is reversible, whether it requires the API key in apiKey/restEndpoint (implied by parameters but not explained), what happens to users not yet in Braze, and whether the update is synchronous or queued.

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 single sentence is front-loaded with the action and resource and contains no filler. It is appropriately terse, though its brevity is achieved partly by omitting necessary detail rather than by 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 no annotations and no output schema, the description is far too thin. It does not explain the auth/endpoint requirements that three of the four parameters imply, nor how it differs from the six other subscription-related siblings, leaving an agent without enough context to select or 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 100%, so the schema already documents email, apiKey, restEndpoint, and the subscription_state enum. The description adds nothing beyond that baseline, so a 3 is the appropriate floor rather than a higher score.

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

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

The description states a clear verb (Change) and resource (email subscription status for users), making the purpose immediately legible. However, it does not distinguish this tool from its many near-identical siblings such as subscription_status_set, subscription_status_set_v2, subscription_user_status, and subscription_status_get, leaving the agent to guess which variant applies.

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 prerequisites, and no mention of the alternative subscription tools despite a sibling list full of near-duplicates. An agent cannot tell from the description whether this is the v1 or legacy path versus subscription_status_set_v2.

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

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

No annotations are provided, so the description carries the full burden, yet it says nothing about authentication requirements (apiKey/restEndpoint are visible only in the schema), whether creation is idempotent, what happens on name collision, or what the response contains. For a mutation tool with zero annotation coverage this is a significant gap.

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

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

A single short, front-loaded sentence with no wasted words. It is efficient, though the terseness borders on under-specification rather than optimal conciseness.

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

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

A mutation tool with 8 parameters, no annotations, and no output schema needs more than a five-word sentence. Nothing about auth, error behavior, response shape, or field semantics beyond the schema is provided.

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

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

Schema description coverage is 100% with all 8 parameters documented in the schema itself, so the baseline of 3 applies. The description adds no format, constraint, or default information beyond what the schema already provides.

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

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

States a specific verb (Create) and resource (email template), which distinguishes it from email_templates_list, email_templates_info, and email_templates_update in the sibling set. However, it does not explicitly differentiate itself from those siblings, so it stops short of a 5.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as email_templates_update for modifying an existing template. The agent must infer usage entirely 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?

No annotations are provided, so the description carries the full burden. "Get" implies a safe read, but there is no disclosure of auth requirements beyond the key/endpoint params, no rate-limit or failure notes, and no hint at what "details" are returned.

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

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

A single front-loaded sentence with no wasted words. It is efficient, though it borders on under-specification rather than being genuinely informative.

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

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

For a simple single-item read with a fully documented schema and no output schema, the description is minimally adequate. It leaves unclear what "details" comprise and offers no routing guidance, but nothing critical to correct invocation is missing.

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

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

Schema description coverage is 100% (apiKey, restEndpoint, email_template_id all documented), so the schema already carries parameter meaning. The description adds nothing beyond that baseline, so a 3 is warranted.

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

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

States a specific verb ("Get") and resource ("details for a specific email template"), and the word "specific" plus singular template signals retrieval of one item. This implicitly contrasts with sibling email_templates_list, though it never names it 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 explicit guidance on when to use this versus email_templates_list, email_templates_update, or content_blocks_info. Usage is only inferable from the name and the word "specific".

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

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

No annotations are provided, so the description carries the full burden. The description doesn't disclose any behavioral traits such as pagination behavior, authentication requirements, rate limits, or output format. It's purely a restatement of the obvious.

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

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

Single short sentence, front-loaded with the key action and resource. No unnecessary words.

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

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

For a tool with 6 parameters, no annotations, and no output schema, the description is too sparse. It doesn't explain pagination, filtering capabilities (despite modified_after/before parameters), or what the return value contains. Missing key context an agent would need 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 83%, so the schema already documents most parameters (limit, apiKey, restEndpoint, modified_after, modified_before). The description adds no parameter details. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

States a specific verb (List) and resource (email templates) with scope (in the workspace). Clear enough to distinguish from siblings like email_templates_info and email_templates_create, though it doesn't explicitly name them.

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

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

No guidance on when to use this tool vs. alternatives. With siblings such as email_templates_info, content_blocks_list, and campaigns_list, there's no indication of when this is appropriate. Simply implies it's for listing templates via 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure and falls short. It does not say whether updates are partial or full-replacement, whether the template must already exist, whether auth is required (apiKey/restEndpoint are schema params), or whether changes are reversible. For a mutation tool with zero annotation coverage 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 short sentence is front-loaded and free of waste, but for a nine-parameter mutation endpoint this is terse to the point of under-specification rather than genuinely efficient. It is neither bloated nor informative.

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 mutation tool with no annotations, no output schema, and no partial-update semantics should explain more about what changes and what the caller must supply. Given the complexity of a nine-param template update, the description leaves the agent guessing about behavior.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters (body, subject, tags, template_name, etc.). The description adds no format or semantics beyond that, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb+resource combination ('Update an existing email template'), which is unambiguous and accurate. It does not differentiate from siblings like email_templates_create or email_templates_info, but the resource is clear enough that a name-plus-description read is sufficient.

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 email_templates_create or content_blocks_update. The agent must infer that this is the mutation path for an already-existing template.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only query but says nothing about authentication (the required apiKey/restEndpoint params), rate limits, pagination behavior, or the shape of results, all of which matter for an 8-parameter API 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?

One tight sentence with the resource and scope front-loaded and no wasted words. It is efficient, though brevity here edges toward under-specification for an 8-param 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?

With no annotations, no output schema, 8 parameters, and a dense sibling set, the description is too thin. It omits authentication requirements, pagination semantics, and any differentiation from the many adjacent email/subscription tools an agent could confuse it with.

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 high (88%), so the schema already documents email, limit, offset, dates, and endpoint. The description adds only the date-range framing that start_date/end_date already imply, contributing little beyond the schema; baseline 3 applies.

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

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

States a specific verb (Query) and resource (emails that have unsubscribed) with a scope (within a date range). However, it does not distinguish this tool from closely related siblings like email_hard_bounces, email_subscription_status, or subscription_status_get, leaving the agent to infer the difference between unsubscribes and bounce/subscription events.

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

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

The description gives no explicit when-to-use or when-not-to-use guidance and does not name any alternative sibling. Given the crowded email/subscription family, an agent cannot tell from this sentence when to prefer this tool over email_hard_bounces or subscription_status_get.

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

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

No annotations are provided, so the description carries the full burden, and it discloses nothing: no auth requirement (despite apiKey/restEndpoint params), no rate limits, no return shape, no note on how 'length' plus 'unit' interact with 'ending_at'. One sentence of pure restatement is all that is offered for a 7-parameter analytics call.

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

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

A single front-loaded sentence with zero filler, which is structurally clean. The problem is under-specification rather than verbosity, so the sentence earns its place but is not enough.

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 tool with no output schema and no annotations, the description is far too thin: no pagination, response structure, auth, or default behavior for 'unit'/'ending_at' is given. The agent has no way to know what result to expect.

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

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

Schema description coverage is only 57%, so the description must compensate, but it adds no meaning: 'event', 'length' ('Number of days'), 'unit' enum values, and 'ending_at' are entirely undocumented in prose. 'Over time' loosely gestures at unit/length but supplies no format or interaction rules.

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 verb (Get) and resource (custom event analytics) with the temporal qualifier 'over time'. It is distinguishable from events_list (which lists events) and from kpi_* tools, but it never names a sibling or scopes what 'over time' means, leaving the boundary with siblings like sessions_analytics fuzzy.

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 alternatives named. An agent choosing among events_list, events_analytics, and the kpi_* tools gets no routing help from the description.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read operation via 'List', but omits authentication needs (apiKey), pagination behavior (page), rate limits, and whether results are complete or paged.

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

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

A single, front-loaded sentence with zero waste. It is appropriately sized for a simple list endpoint.

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

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

With no output schema, no annotations, and incomplete parameter descriptions, the definition is too thin for confident invocation. It lacks auth, pagination, and return format details that an agent would need.

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

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

Schema description coverage is 67%; apiKey and restEndpoint are documented in the schema, but page is undocumented. The description adds no parameter meaning at all, so it fails to compensate for the page 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 ('custom events tracked in the app'), making the enumeration purpose clear. However, it does not differentiate from close siblings like events_analytics or other list tools, so it falls short of a 5.

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

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

Provides no when-to-use guidance, no alternatives such as events_analytics for event metrics, and no conditions for using this list. The agent must infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral-disclosure burden. It does not state that this is a read-only operation, does not mention authentication requirements, rate limits, pagination, or what the returned time series looks like.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately concise for a simple metric endpoint, though its brevity contributes to the broader completeness gaps.

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

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

For a 5-parameter analytics tool with no annotations and no output schema, one sentence is insufficient. It omits return format, time-window semantics, default behavior, and authentication context that an agent would need to call 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 about 80%, so the schema largely documents parameters such as apiKey, app_id, length, and restEndpoint. The description adds no parameter meaning beyond the schema, and ending_at lacks a schema description, leaving a minor gap.

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

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

The description states a specific metric and temporal scope: 'daily active users (DAU) over time.' It clearly identifies the resource, though it does not explicitly differentiate this tool from siblings such as kpi_mau or kpi_new_users.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The only usage signal is the metric name itself, which is implicit at best.

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

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

With no annotations, the description carries the full behavioral burden but only implies a read operation via 'Get'. It does not disclose authentication requirements despite an apiKey parameter, rate limits, time granularity, or pagination behavior.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately concise, though the brevity contributes to gaps captured in other dimensions.

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

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

For a tool with five parameters, no annotations, and no output schema, the description is too sparse. It does not explain undocumented parameters, usage context, or behavioral details an agent would need 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 60%, leaving app_id and ending_at undocumented. The description adds no parameter meaning beyond what the schema already provides, and does not 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 states a specific verb ('Get'), resource ('monthly active users (MAU)'), and temporal scope ('over time'). It implicitly distinguishes itself from sibling kpi_dau by using 'monthly' versus 'daily', but it does not explicitly name or contrast with any 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 provides no guidance on when to use this tool versus alternatives such as kpi_dau, kpi_new_users, or kpi_uninstalls. It also omits prerequisites or conditions for selecting this metric.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says nothing about whether this is a read-only query, what permissions or API key are required, rate limits, or what granularity/format the time series returns.

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

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

The single sentence is front-loaded and free of filler, which is good. However, it is terse to the point of under-specification for a 5-parameter analytics tool, so it earns only a middling score.

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 5 parameters, no annotations, no output schema, and two undocumented parameters, the description leaves too much unexplained. An agent cannot determine the returned granularity, the time-range semantics, or the authentication expectations from this definition alone.

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

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

Schema coverage is only 60% and the description adds no parameter meaning at all. It does not explain 'length' (days), 'ending_at' (undocumented in schema), 'app_id' (undocumented), or how they shape the returned series.

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 ('Get') and resource ('new users count') with a temporal scope ('over time'), which cleanly separates it from siblings like kpi_dau, kpi_mau, and kpi_uninstalls. It does not explicitly name those siblings, so it falls short of a 5.

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

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

There is no indication of when to use this tool versus the other KPI tools (kpi_dau, kpi_mau) or the users_* analytics tools. No prerequisites, exclusions, or alternatives are given; usage is only weakly implied by 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?

No annotations are provided, so the description carries the full burden. It implies a read operation and a time-series result, but says nothing about auth requirements, rate limits, data freshness, timezone handling, maximum ranges, or return 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?

A single front-loaded sentence with no wasted words. It is as concise as possible while still naming the operation and resource.

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

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

For a 5-parameter analytics tool with no annotations, no output schema, and 60% schema description coverage, the one-line description is too thin. It omits required parameter semantics, return value expectations, and behavioral constraints an agent would need to call it correctly.

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

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

Schema description coverage is 60%, with only apiKey and length described in the schema. The description adds no parameter meaning; 'over time' loosely hints at temporal parameters but does not explain app_id, ending_at, or how length interacts with the result.

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

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

The description states a specific verb ('Get') and resource ('app uninstalls over time'), which is clear enough to distinguish it from most siblings. However, it does not explicitly differentiate itself from other KPI tools like kpi_dau, kpi_mau, or kpi_new_users.

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

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

There is no guidance on when to use this tool versus alternatives such as sessions_analytics or other KPI endpoints. The implied context is analytics, but no explicit when-to-use 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?

No annotations are provided, so the description carries the full behavioral burden. It is silent on whether this needs API credentials, what ending the activity does, whether updates are reversible, and typical latency/rate limits for a write against a live user-facing surface.

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, purpose first and use cases second, with zero filler. Appropriately sized for the information it chooses to convey.

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 nine-parameter mutation tool with a nested notification object, no annotations and no output schema, the description leaves too much uncovered. It should at minimum signal that ending an activity is irreversible and that authenticated API credentials are required.

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

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

Schema description coverage is 89%, so the schema already documents most parameters including apiKey, app_id, activity_id, stale_date, dismissal_date and end_activity. The description only loosely hints at what content_state holds (scores, delivery status) and adds no format or syntax beyond the schema, so the baseline 3 applies.

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

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

States a specific verb ('Update') and resource ('iOS Live Activity'), so the operation is unambiguous. It does not need to differentiate from siblings since none of the listed tools touch Live Activities, but it also does not explicitly claim that territory.

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?

'Used for real-time updates like sports scores, delivery tracking' gives the usage context and implies when to reach for it. It stops short of stating prerequisites, when-not-to-use, or any alternative, leaving the selection logic incomplete.

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

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

No annotations are provided, so the description carries the full burden. 'Schedule a message to be sent' implies a write/mutation operation with delayed delivery, but the description doesn't state permissions required, whether the schedule is cancellable/updatable, whether the message validates immediately, or what happens on failure. For a mutation tool with zero annotation coverage and 11 parameters, this is a significant gap.

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

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

A single short sentence with no filler. It's appropriately sized as far as it goes, but the brevity reflects under-specification rather than efficient information density.

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 11 parameters, nested objects (audience, messages, schedule), 18% schema coverage, no annotations, and no output schema, the description is far too thin. It omits any mention of Braze, audience targeting, required vs optional params, or mutation semantics, leaving the agent without critical context to call this tool correctly.

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

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

Schema description coverage is only 18%, well below the 50% threshold, so the description must compensate—and it doesn't. It mentions only 'a specific time' (mapping to the schedule.time param), leaving 10 other parameters (campaign_id, segment_id, audience, messages, broadcast, send_id, apiKey, etc.) completely undocumented in the description. The description adds no meaningful semantic guidance beyond what's already in the sparse schema.

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

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

The description states a clear verb ('Schedule') and resource ('a message') with a timing qualifier, which is understandable on its own. However, it doesn't distinguish this tool from siblings like messages_send (immediate send) or campaigns_schedule_create, canvas_schedule_create, and messages_schedule_update. A single sentence covering only the most basic intent leaves the agent guessing about which scheduling tool to pick.

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 over messages_send, campaign/canvas scheduling variants, or messages_schedule_update. The agent has no signal about the distinction between scheduling a direct message versus a campaign/canvas, or when immediate send is more appropriate.

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

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

With no annotations, the description carries the full burden of behavioral disclosure for a destructive operation. It states only that a scheduled message is deleted, without explaining whether deletion is permanent, what permissions are required, or what happens if the schedule has already been sent.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately concise for stating the tool's core action.

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 mutation tool with no annotations and no output schema, the description is too thin. It should at least clarify the effects of deletion, authentication expectations, or error cases to help an agent 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 coverage is 100%, so the schema already documents apiKey, schedule_id, and restEndpoint. The description adds no parameter-level meaning beyond what the schema provides, making the baseline score of 3 appropriate.

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

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

The description states a specific verb ('Delete') and resource ('a previously scheduled message'), making the core action clear. It does not explicitly differentiate itself from closely named siblings like campaigns_schedule_delete or canvas_schedule_delete, but the word 'message' narrows scope adequately.

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

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

The description gives no guidance on when to use this tool versus alternatives such as messages_schedule_update or campaigns_schedule_delete. It also omits any prerequisites, like whether the schedule must still be pending.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says nothing about authentication requirements, whether the update is a full replacement or partial patch, what happens to existing schedule fields not supplied, or any side effects or rate limits. For a mutation tool, this is a severe gap.

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

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

The single sentence is concise and front-loaded, but it is so minimal that it barely earns its place. It avoids verbosity yet fails to provide meaningful content, making it adequate but clearly under-specified.

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

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

With no output schema, no annotations, five parameters including nested objects, and only a one-line description, the definition is grossly incomplete. It does not provide enough context for an agent to safely invoke this mutation tool.

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