EventSend

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds meaningful behavioral context: totals come from daily agg-regates while failure details come from raw deliveries within retention, and it discloses what kinds of failures are returned. This is useful beyond the annotations and contains no contradicction.

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

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

Two sentences, front-loaded with the main purpouse, then the delivered output, then the data-source caveat. Every sentence earns its place and there is no filler or redundant restating of the tool name.

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

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

With no output schema, the description explains what is returned: delivered, failed, success rate, response time, held-back items, and recent failures with errors. It also clarifies the freshness/aggregation model. It could be slightly richer about how failures_limit/date cutoffs shape the failure sample, but the schema covers most of that.

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

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

Schema description coverage is 88%, so the schema already carries most parameter meaning. The description does not add parameter-level details, though it does frame the notion of 'calendar days' and 'per destination'. With high schema coverage, baseline 3 is appriate.

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

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

The description names a specific verb and resource: it reports delivery health per destination over a date range, with concrete metrics (delivered, failed, success rate, response time, held-back items) and recent failed deliveries with errors. This clearly differentiates it from sibling tools like get_usage or event_stats, even without naming 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?

The description provides a clear usage context: for delivery health/status per destination over calendar days. It does not explicitly say when not to use it or name alternative tools, but the purpose is specific enough that an agent can identify when this tool fits. A small exclusion or pointer to siblings would make it fully explicit.

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

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

Annotations already mark the tool as read-only, idempotent, and non-destructive, so the behavioral safety profile is covered. The description adds useful context by specifying what configuration data is returned and positioning the tool as a prerequisite for filtering operations.

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

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

The description is two sentences with no filler: the first packs the full scope of returned configuration into a compact enumeration, and the second states the intended call context. It is front-loaded and every clause earns its place.

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

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

For a read-only configuration lookup with one optional parameter and no output schema, the description adequately covers what is returned and when to call it. It does not specify the exact response format, but that is a minor gap given the simple metadata nature of the tool.

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

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

Schema description coverage is 100%, with the single optional 'org' parameter already documented, including the default behavior and a reference to list_organizations. The tool description adds no further parameter-level semantics, so the baseline score 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?

The description clearly identifies the resource as the organization's configuration and enumerates its components: routes, sources, topics, and destinations with their ids and names. It conveys the tool's purpose well, though it relies on a noun phrase rather than an explicit verb like 'describes' or 'lists'.

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

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

The description explicitly says to 'Call it before filtering another tool by route, source or destination,' giving clear guidance on when to use it. It does not name specific sibling tools or state when not to use it, so it stops short of full exclusion guidance.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds useful context: data source (daily aggregates), retention (12 months), and timezone handling. However, it does not disclose output format, behavior with empty results, or what 'previous period' means, leaving some ambiguity.

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

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

Two concise sentences front-load the core purpose ('Event counts over a range of calendar days') and then add relevant detail. No fluff or redundancy; every phrase contributes value.

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

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

The description covers key aspects: what is counted, scope, data source, and timezone. However, terms like 'per level' and 'previous period' are ambiguous—'level' could refer to severity or event type, and 'previous period' is not defined (previous day, week, or same period last year). Given no output schema, these gaps could confuse an agent, but overall it is adequate for a reporting tool.

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

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

Schema description coverage is 100%, with each parameter clearly explained (e.g., 'to' as 'Last calendar date (YYYY-MM-DD, org-local); with from.'). The description does not add parameter-specific details beyond the schema, but it provides general context ('Dates only') that aligns with the schema. Baseline 3 is appropriate given high schema 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 clearly states the tool's purpose: 'Event counts over a range of calendar days' with explicit dimensions (per day, per level, in total, against previous period) and scope (whole organization or one event name). This distinguishes it from siblings like get_user_timeline (per-user activity) or get_event (single event details) without needing to open schemas.

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

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

The description implies usage for aggregated event counts over time but does not explicitly state when to use this tool versus alternatives or when not to use it. There are no exclusions mentioned, and no reference to sibling tools. The context ('Dates only, org time zone') is a constraint, not usage guidance.

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

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

Annotations already declare readOnlyHint/idempotentHint/destructiveHint-false, so the safety profile is covered. The description adds real behavioral value: delivery history ordering (newest first), per-page paging through deliveries_cursor, and inclusion of both payload and attempts. Minor gap: nothing about not-found behavior, acceptable for a fetch 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 sentences with zero fluff: the first delivers verb+resource+output shape, the second delivers routing guidance. Every sentence earns its place and the core action is front-loaded.

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

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

With no output schema, the description carries the burden of stating the return shape and does so (payload + deliveries page). Combined with annotations (safety) and a well-described schema, an agent can select and invoke it correctly. Small remaining gaps: no error behavior and no boundary against aggregate siblings like event_stats/delivery_health, but these are minor for a single-fetch tool.

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

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

Schema coverage is 75% — id, org, and deliveries_cursor are already described; only deliveries_limit lacks prose, but its default/min/max carry meaning. The description contributes little param-level info beyond re-stating that deliveries_cursor is the paging handle, which the schema already conveys. 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?

States a specific verb (Fetches) + resource (one event by id) + what is returned (full payload and a page of delivery history, newest first). The positioning as a follow-up to search_events/get_user_timeline differentiates it from siblings without opening their schemas.

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

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

Explicit workflow guidance: 'Use it after search_events or get_user_timeline when the payload or every delivery attempt is needed.' It names the tools that precede it and the condition that selects it, but does'nt explicitly state when-not to use it (e.g., when aggregates would suffice, such as event_stats).

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

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

The annotations already cover the safety profile with readOnlyHint, idempotentHint, and destructiveHint. The description adds context about the billing-period scope and the run-rate projection, which is useful, but it does not reveal additional behavioral edge cases. No contradiction with annotations exists.

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

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

The description is one compact sentence, front-loaded with the core concept 'event quota,' and the em-dash list efficiently conveys all returned components. There is no filler or redundant wording, and every listed element adds value.

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

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

For a simple read-only lookup with one optional parameter, the description is self-sufficient: it enumerates the returned data fields, which is especially important given there is no output schema. The schema already covers the default organization behavior, so nothing critical is missing for an agent to call the tool correctly.

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

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

The single optional parameter org is fully documented in the schema, including default behavior and a pointer to list_organizations, giving 100% schema description coverage. The tool description adds no parameter-level meaning beyond the schema, so the baseline score 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?

The description identifies the resource (organization event quota) and enumerates the returned data points (used, limit, remaining, overage, run-rate projection, plan, retention), making the tool's function clear. It lacks an explicit verb and does not explicitly distinguish it from siblings like event_stats, but the noun-phrase description is specific enough for an agent to select 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?

There is no guidance on when to use this tool versus alternatives such as event_stats or list_organizations. The intended use for quota checks is implied, but no explicit conditions, exclusions, or alternative references are provided.

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

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

Beyond the readOnlyHint and idempotentHint annotations, the description adds meaningful behavioral detail: raw events are returned newest-first, a range summary appears on the first page, results are bounded by retention, and pagination uses next_cursor until exhausted. This is valuable runtime context that annotations do not provide.

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

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

The description is compact and front-loaded: the core behavior is in the first sentence, followed by retention and pagination notes. The phrase 'Page with next_cursor until exhausted is true' is grammatically awkward but adds necessary loop-termination information without waste.

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

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

For a read-only, idempotent tool with no output schema, the description covers the key operational details: filtering, ordering, first-page summary, retention, and pagination. It does not describe the exact result shape or explicitly route away from sibling tools, but those gaps are minor given the annotations and schema coverage.

Complex tools with many parameters or behaviors need more documentation. 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%), with org, since, user_ids, and cursor already documented. The tool description adds little parameter-level meaning beyond what the schema already says; the 'given identifiers' and 'next_cursor' references mirror the schema descriptions. It also does not compensate for the undocumented 'limit' parameter.

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

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

The description clearly identifies the resource as 'the timeline of one customer' and the selection mechanism as 'every raw event whose user_id matches any of the given identifiers.' It also specifies ordering (newest first), which distinguishes it from sibling tools like get_event or event_stats without needing to 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?

The use context is clear: this is the tool for retrieving a single customer's raw event stream by user_id. It does not explicitly compare itself to alternatives like search_events or state when not to use it, but the purpose is specific enough that an agent can infer when it applies.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds useful context beyond annotations: data comes from daily aggregates, retention is 12 months, and dates are in the organization's time zone. It does not contradict annotations.

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

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

Two sentences with no filler. The first sentence states the result and data source; the second gives the primary use case and the key date/time-zone qualifier. Every sentence earns its place.

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

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

For a read-only list tool with no output schema, the description explains the core output (frequent event names, counts, share) and the supporting data model. It could mention limit behavior or retention edge cases, but the schema and annotations cover the remaining operational details adequately.

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

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

Schema description coverage is high at 80%, so the schema carries most parameter meaning. The description reinforces date-related semantics like calendar days and org-local time zone, but adds little for the limit parameter, which 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 clearly states the tool lists the organization's most frequent event names with counts and share over a date range. It also frames its role as a precursor to searching or computing stats, distinguishing it from siblings like search_events and event_stats.

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

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

The description gives clear usage context: use it to learn what an organization sends before searching or computing stats. It does not name sibling tools explicitly or provide explicit when-not-to-use conditions, but the intended workflow is clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds useful behavior beyond those: results are limited to what the credential can read, the default organization is marked, and the returned slug is meant for downstream calls. This is meaningful context without contradicting the annotations.

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

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

Two sentences with no filler. The purpose is front-loaded, and the usage instruction follows immediately. Every sentence earns its place.

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

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

For a zero-parameter, read-only list tool, the description is complete: it says what is returned, when to call it, and how to use the output. The lack of an output schema is mitigated because the description clearly conveys the key output concept (default-marked organizations with slugs).

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

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

The tool has zero parameters, so the baseline is 4. The description adds no input-parameter meaning because there are none, but it usefully explains that the output's organization slug should be used as the `org` parameter in later calls, which helps the agent understand the data flow.

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

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

The description states a specific action and resource: 'Lists the organizations this credential can read, with the default one marked.' This clearly differentiates it from sibling tools like list_event_names and makes the tool's scope (credential-readable organizations) 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?

It gives explicit when-to-use guidance: 'Call it first when the user names an organization, or when another tool answers that no default is set.' It also tells the agent exactly how to use the result: pass the organization's slug as `org` on every later call.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds substantial behavioral context beyond that: results are raw events ordered newest-first, each includes latest deliveries, results are bounded by plan retention, and pagination has a non-obvious signal where a short page with a cursor means the search window ended. This is exactly the kind of nuance an agent needs to interpret results correctly.

Agents need to know what a tool does to the 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 dense sentences carry all the information with no filler. The core purpose and ordering are front-loaded, and the non-obvious pagination caveat is placed second where it can be noticed before use. Every clause earns its place without repeating schema content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 13-parameter search tool with no output schema, the description covers ordering, retention bounds, pagination behavior, and result shape, which is unusually complete. It leaves minor gaps such as the exact meaning of include_payload and how filters combine, but these are small relative to the operational detail already 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 coverage is 77%, so the schema already documents most parameters. The description adds value by grouping the filter dimensions, clarifying that user_id is the sender's customer identifier, and explaining that results include each event's latest deliveries, which informs interpretation beyond individual parameter descriptions. It doesn't detail include_payload's effect, but the schema covers most of the 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 ('Searches'), a precise resource ('organization's recent raw events'), and enumerates the filter dimensions: text, event name, level, delivery status, user_id, route, source, and time. It also specifies the ordering (newest first) and that each event includes its latest deliveries, which clearly differentiates it from siblings like event_stats or get_event even without naming 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?

The description gives strong operational context, such as retention bounds and pagination semantics, but it never explicitly says when to prefer search_events over get_event, event_stats, or get_user_timeline, nor when not to use it. Usage context is implied rather than stated with alternatives or exclusions.

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