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

Annotations already cover the safety profile (readOnly, idempotent, openWorld, non-destructive), so the description is free to add semantics instead of repeating them. It does: results are aggregates by severity, a count at or above a threshold, newly-reached findings since an earlier run, and findings returned as ids rather than values. That novelty and id-only behavior is useful context beyond the annotations.

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

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

A single dense but well-structured sentence that front-loads the subject ('what programs on one es-python machine reported') before enumerating outputs. Nothing is wasted, though the enumeration is long.

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

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

An output schema exists, so return structure need not be spelled out, and the description still clarifies the id-not-values convention and the novelty aspect. Combined with fully documented parameters and annotations, an agent has what it needs 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?

Schema description coverage is 100%, so every parameter is already documented in the schema, including min_severity's default of 'high' and limit's worst-first ordering. The description reinforces the threshold concept but adds no format or semantics beyond the schema, so the 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 names the resource (findings from programs), the scope (one machine, since a moment), and the shape of the result (severity counts, threshold counts, novel findings, finding ids). It is specific enough that an agent can distinguish it from generic event/runs siblings, 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?

There is no when-to-use or when-not-to-use guidance. The agent must infer from 'one es-python machine reported since a moment' that this is the machine-scoped CI findings tool, and nothing points to alternatives such as list_runs or search_events for related questions.

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, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds useful domain context by distinguishing live vs suppressed buckets and mentioning the monthly quota count, but it omits anything about result shape, defaults, or account-level scope beyond the annotations.

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

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

It is a single run-on sentence whose trailing parenthetical is grammatically broken and hard to parse. The core countable dimensions should be front-loaded as a clean list, but instead they are tangled with the quota clause.

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?

An output schema exists, so return values need not be restated, and annotations cover safety. Still, for a tool sitting among many event-related siblings, the description lacks the routing guidance and clarity an agent needs to pick it over event_stats or search_events, and the ambiguous quota clause leaves the tool's exact scope uncertain.

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

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

Schema description coverage is 100%, and the schema already explains that view maps to 'python'/'browser' and bucket to live/suppressed/all. The description echoes these concepts loosely ("per product list, live versus suppressed") without adding format or default details beyond the schema, 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 indicates a counting/aggregation tool ("How many events the account has") and names the dimensions: per product, live vs suppressed, and quota usage. However, it never clearly distinguishes itself from siblings like event_stats or get_event_uniqueness, and the final parenthetical ("pass view for the number one product's list is capped by") is nearly unintelligible, blurring rather than sharpening the purpose.

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

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

There is no statement of when to use this tool versus event_stats, search_events, or list_event_names, and no note about prerequisites. The only implicit guidance is "pass view" for a per-product count, which is embedded in a garbled clause rather than framed as a decision 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?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), so the description's main added value is the shape of the graph it returns and the scale warning. It does not disclose scoping limits (e.g. es-python-only behavior, which the schema notes for run_uid) or any cost/latency characteristics beyond the date-window hint.

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

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

Two sentences, front-loaded with the graph concept and closed with an actionable performance note; no filler. It could be tightened slightly but every clause carries information.

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

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

For a 15-parameter tool with an output schema and full annotations, the description covers the conceptual model and the key scale caveat, which is enough for an agent to call it correctly. Missing is routing guidance against the numerous sibling event 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 all 15 parameters are already documented in the schema; the description merely gestures at the source/file/sink/severity concepts those parameters filter on without adding syntax or edge-case meaning. This is the expected baseline when the schema carries the burden.

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 relationship: it renders es-python taint events as a graph of sources → files → sinks, and describes the per-node payload (event/hit counts, worst severity). That is far more specific than siblings like event_stats or event_counts, though it never names a sibling to differentiate itself directly.

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

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

The only guidance is 'Prefer a date window on a large account', which is a performance tip about a parameter rather than a statement of when this tool should be chosen over search_events, event_stats, or event_counts. No when-not conditions are given.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context in the form of fixed aggregation windows (last hour/day/week, 14-day timeline) and the fact that it returns recent events as well as counts, which tells the agent the output is bounded and time-scoped rather than a full dump. It says nothing about latency, caching or rate limits.

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

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

A single front-loaded sentence that leads with the framing (dashboard summary) before enumerating the payload. The enumeration is long but each item is a distinct returned metric, so it mostly earns its place; it could be trimmed given an output schema already documents the shape.

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

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

The tool is simple (no params, full annotation coverage, output schema present), so the description need not explain return values — yet nearly all of its content restates the payload that the output schema already defines. What is genuinely missing is disambiguation from the many sibling event tools, which is the main decision an agent faces here.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. The description correctly implies there is nothing to configure: the windows are fixed at hour/day/week and 14 days. No parameter meaning is missing because there are no parameters.

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

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

The description names the resource (events) and specifies exactly what the tool returns: a dashboard-style aggregate summary with totals, time-window counts, top types, recent events and a 14-day timeline. That is far more specific than a tautology. It does not, however, distinguish this aggregate view from siblings such as event_counts or event_map, which an agent may confuse it with.

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 statement and no mention of alternatives. With event_counts, event_map, search_events and get_event in the sibling list, the description never says when this summary is preferable to a raw count or a search. The agent must infer routing from the field list alone.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered; the description adds genuine context beyond them, notably that the API key is never returned ('never the key itself') and that setup progress plus a next step is included. That security note and the setup-state disclosure are the kind of traits annotations cannot express.

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

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

A single sentence with no filler; content is front-loaded with the most substantive item (profile/limits/permissions) first. Slightly parenthetical but entirely earned.

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?

An output schema exists, so return values need no explanation, and annotations cover the safety profile; the description adequately explains what the call yields. Nothing critical is missing for a no-argument read tool.

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

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

The tool takes zero parameters, so the baseline is 4 — there is nothing for the description to clarify in terms of arguments and it does not pretend otherwise.

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 resource (the account) and enumerates its contents clearly: profile, limits, permissions, API key scope/expiry, and es-python setup progress. It is specific enough to distinguish from the list_*/event_* siblings, though it lacks a crisp action verb and never explicitly contrasts itself against alternatives.

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

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

Usage is implied rather than stated — an agent can infer it should call this when it needs account-level context, but there is no explicit when-to-use, no prerequisites, and no alternatives named. Adequate for a zero-argument getter, but no real 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is fully covered by structured data. The description adds one genuinely useful behavioral nuance — source code is returned only 'when the machine sends it' — but otherwise just lists payload contents. No auth, latency, or rate-limit context.

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

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

One sentence, front-loaded with the core action ('Get one event's full detail') followed by the payload inventory. Every clause carries information, though the enumerated list is longer than strictly needed.

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

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

For a one-parameter read tool with full annotations and an output schema, the description is broadly sufficient; return-value detail is technically redundant with the output schema but acts as a useful preview. The missing piece is routing guidance against sibling read 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?

There is a single parameter with 100% schema description coverage, so the schema already explains that event_id is the 'id' field from a search_events result. The description adds nothing about the parameter. Baseline 3 applies when the schema does all the work.

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 (one event) and enumerates what 'full detail' means: stack trace, origin, creation site, source code, note, and producing runs. It is unmistakable what the tool returns. It does not, however, name or contrast with siblings like search_events or event_map, so the agent must infer the distinction 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?

Usage is only implied by the singular 'one event' plus the schema's note that the id comes from a search_events result. There is no explicit statement of when to call this versus search_events, event_map, or list_runs, and no prerequisites or exclusions are given.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint, so the safety profile is fully covered elsewhere. The description adds no behavioral context of its own — nothing about permissions, what the returned definition contains, or how scope affects results.

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. The only knock is that it is a sentence fragment rather than a complete declarative statement of what the tool does.

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?

An output schema exists and both parameters are fully described, so return values and inputs need not be explained in the description. What is missing is usage context — when this definition-retrieval tool is the right choice versus the many sibling event 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 both parameters are already documented in the schema itself. The phrase 'for one product and scope' loosely echoes agent_kind and machine, adding only a faint conceptual link beyond what the schema provides, which matches the baseline 3.

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 concept (the criteria that make two detections the same event) and ties it to product and scope, which lets an agent infer the resource. But it is a noun phrase with no verb, so it never actually states that the tool *returns* the uniqueness definition. Purpose is understandable yet not sharply 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?

There is no when-to-use, no when-not-to-use, and no reference to any alternative tool among the many event siblings (search_events, event_stats, event_counts, get_event). The agent must guess the calling 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?

Annotations already declare read-only, idempotent, non-destructive, open-world behavior, so the safety profile is covered. The description adds genuine domain semantics beyond that: the three-state value model (on/off/unset) and the rule that unset inherits from the level above, which is essential to interpreting results.

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

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

Two tight sentences with no filler. The subject (what the tool returns) is front-loaded and the qualifier about unset/inheritance follows immediately.

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?

An output schema exists, so return values need no prose explanation, and the one optional parameter is fully described in the schema. The three-state/inheritance semantics fill the main interpretive gap. Only the scope hierarchy itself (which levels inherit from which) is left implicit.

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

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

Schema coverage is 100% and the machine parameter is documented richly in the schema, including the list_machines source and the meaning of omitting it (account-wide/global scope). The description adds no parameter detail, so baseline 3 applies since the schema carries the load.

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 resource and what it represents: the kinds of incoming data a given scope treats as untrusted. The agent can tell it apart from rule, filter, machine and event siblings. It does not explicitly name or contrast any sibling, so it stops short of a 5.

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

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

There is no when-to-use or when-not-to-use guidance. Nothing tells the agent whether this is for auditing current taint policy versus troubleshooting detections, and no alternative tool is referenced. Usage is only inferable from the verb in the name.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive), yet the description adds three genuinely useful behavioral facts: newest-first ordering, a 50-per-page page size, and a 30-day retention window. Cursor pagination via before_id/before_ts is implied by "50 per page" but never explained, and auth/rate-limit behavior is unstated, so it is not a 5.

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

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

A single dense sentence packs resource, scope, ordering, page size, retention and content types with zero filler, and the identifying information (audit trail) 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 an output schema present, return values need no explanation, and the description supplies the retention window, ordering and page size an agent needs to page correctly. It is only incomplete in sibling routing — nothing tells the agent when to prefer search_events or event_stats over this 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%, so action, outcome, before_id and before_ts are all already documented with examples and enum values. The description adds no syntax or usage detail about those filters, 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?

Names a specific resource — "the account's audit trail" — and enumerates the event kinds it covers (sign-ins, machine changes, key generation, API calls), which makes it distinguishable from generic event tools. It never states the verb explicitly (it is a listing tool), and it does not name the sibling (search_events) it is closest to, so it stops short of a 5.

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

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

There is no when-to-use or when-not-to-use guidance, no prerequisites, and no routing to alternatives such as search_events or event_stats despite 18 siblings. The content enumeration only faintly implies the use case, which is weaker than the 'implied usage' a 3 requires.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is fully covered. The description adds that results are distinct/de-duplicated and account-scoped, which is genuinely useful, but says nothing about result size, ordering, or completeness 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 sentence that front-loads the returned resource and then explains its purpose. No wasted words and no 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?

With an output schema present, the description need not explain return values, and it correctly identifies what is returned and its scope. The only minor gap is that it does not mention whether the list is exhaustive or ordered, which matters slightly for building filters.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline is 4. The only semantic claim ('across the account's events') is implicit scoping with no parameter counterpart.

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

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

The description states a specific resource and scope: the distinct sink labels (the 'where' field) across the account's events. It is clear what the tool enumerates, though it is phrased as a noun fragment rather than a verb, and does not distinguish itself from the similarly named sibling list_labels.

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?

'Useful for building filters' implies the intended downstream use, which gives an agent a reason to call it. However, no alternatives are named (e.g. list_labels vs search_events) and there is no explicit when-to-use or when-not-to-use 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, openWorldHint and destructiveHint=false, so the safety profile is fully covered. The description adds useful domain context about what a filter actually is (standing blacklist/whitelist patterns), but says nothing about pagination, scope, or the shape of the listing beyond that.

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 compact sentence with no filler. It is appropriately sized for a simple read-only listing, though the fragmentary phrasing is a purpose weakness rather than a conciseness one.

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 an output schema present, return values need not be explained, and annotations cover the safety profile. Still, for a tool with 18 siblings, the absence of any usage or routing guidance leaves the definition only minimally adequate.

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

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

Schema description coverage is 100%: the single 'engine' parameter is documented in the schema as 'python' or 'browser' for one product's Filters page. The description does not mention engine or clarify the per-product scoping, so it adds no meaning beyond the schema, making the baseline 3 correct.

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 the resource (the account's event filters) and characterizes it as standing blacklist/whitelist patterns on the events page, which helps distinguish it from list_rules or list_labels. However, it is a noun fragment with no verb, so it never actually states that the tool lists them, leaving the action 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?

There is no when-to-use guidance, no prerequisites, and no reference to alternatives such as list_rules, list_event_names, or event_stats. The agent must infer entirely from the resource name when this tool is the right choice.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is fully covered without description help. The description adds little behavioral context beyond the field list, which the output schema already provides. With annotations carrying the burden, a baseline 3 is appropriate.

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 waste, with the identity of the resource front-loaded and the actionable cross-reference second. 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 zero-param list tool with a full output schema and complete annotation coverage, the description provides what an agent needs: what it returns and how to use it. It could be marginally stronger by noting ordering or scope, but nothing essential 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?

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing for the description to disambiguate, and it correctly focuses on the return payload instead.

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 the resource precisely ('account's triage labels') and enumerates the returned fields (id, name, color), which distinguishes it from unrelated siblings like list_rules or list_machines. The 'list' verb is only implied, and it doesn't explicitly contrast with the 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?

Explicitly tells the agent how the output is consumed: 'Use an id in search_events' labels filter.' This gives clear downstream context and connects to a named sibling. It does not state when to prefer this over alternatives or any prerequisites, so no exclusions exist.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds interpretive value by naming the returned attributes, including the meaning of the flags ('a clone, a stalled install or an old copy still reporting'), but says nothing about auth needs, pagination, or result size for what could be a large account-wide listing.

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

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

A single well-formed sentence that front-loads the scope ('Every machine on the account') before enumerating fields. The field list is long but each element is concrete; nothing is wasted on 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?

An output schema exists, so the description is not obligated to explain return values, and annotations cover the safety profile. For a zero-parameter listing tool this is nearly complete; only pagination or result-size behavior is left unstated.

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

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

The tool takes zero parameters, so the baseline is 4. There is no parameter surface the description could clarify or fail to clarify.

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 and resource ('Every machine on the account') and even scopes it to the full account, which is unambiguous. It does not need to differentiate from siblings because no sibling tool lists machines, but it never explicitly does so either, which is why 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 guidance on when to call this versus alternatives, no note on whether results can be filtered or scoped, and no mention of prerequisites or pagination. The agent is left to 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description need not restate safety. It adds the mode-to-behavior mapping (Hide, Show, Raise, Don't send), which is useful domain context, but omits any mention of pagination, ordering, or what the output 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 two short sentences with no wasted words. However, the mode enumeration is front-loaded as a fragment and the purpose sentence is unusually terse, slightly reducing readability.

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

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

With only one optional parameter and full schema coverage, the description could easily be complete, but it omits the basic purpose of the tool, any usage guidance, and any behavioral details. The mode mapping is helpful but insufficient to compensate for the missing core 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 machine parameter's meaning (public_id, omit for global scope) is fully documented in the schema. The description's mode mapping is not tied to any input parameter, and it adds no meaning 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?

The description states 'The rules in one scope', which identifies the resource (rules) and the scoping concept, but the verb 'list' is only implied by the tool name. The first sentence is terse and does not clearly state what is returned or how it differs from siblings like list_rule_templates.

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

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

No guidance is given on when to use this tool versus alternatives such as list_rule_templates or other list tools. The description notes 'one scope', hinting at the machine parameter, but does not explain the choice between global and machine-scoped rules.

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world, so safety behavior is covered. The description adds the visibility scope (own vs EyalSec templates), which is genuine context, but the 'with their rules and categories' nesting is also conveyed by the output schema.

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, front-loaded with the resource and scope. No filler, though the trailing 'with their rules and categories' clause is largely redundant against the output schema.

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 rich annotations, an output schema, and no parameters, the description covers what an agent needs to call this correctly. The only missing piece is sibling differentiation from list_rules, which is a minor gap for a zero-arg list tool.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing for the description to disambiguate beyond confirming the operation is unpaginated and unfiltered.

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 (implicit list) and resource (rule templates) and clarifies scope: templates the account can see, both its own and EyalSec's. Clear on its own, though it never explicitly contrasts with the sibling list_rules.

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 scoping phrase 'every rule template the account can see' implies this is the unfiltered enumeration of templates, which is usable guidance. But it names no alternative and gives no condition for choosing this over list_rules or list_filters.

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, openWorld, and non-destructive behavior, so the safety profile is covered. The description adds ordering (newest first) and the semantic content of a run plus its relationship to events, which is genuinely useful context beyond the structured fields.

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

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

Two sentences, front-loaded with the core purpose and ordering before the definition and follow-up pointer. No filler; every clause conveys 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?

An output schema exists, so return values need not be explained, and the description covers the resource, its contents, and ordering. It is essentially complete for a list tool, with only minor gaps such as pagination behavior, which the schema's before/limit descriptions already address.

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 (q, limit, before, machine) are already documented in the schema. The description adds no parameter-specific detail, 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 ('runs behind the account's events') and defines the domain term 'run' precisely as one invocation of one monitored program with its command line and event counts. This makes it clearly distinguishable from siblings like search_events and event_counts.

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 a concrete usage path: take a run_uid from here and pass it to search_events to scope events to that run. It lacks an explicit when-to-use-this-vs-alternatives statement (e.g., versus list_activity), but the follow-up guidance makes the intent 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, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context beyond that: no pagination, no auth/permission requirements, no note on how many searches are returned or what 'events-page' scope implies.

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?

It is a single front-loaded sentence with zero padding, which is good, but it is under-specified rather than genuinely concise — the brevity comes from omitted information (scope, product meaning) rather than from tight writing.

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?

An output schema exists, so return values need not be explained, but the description leaves the agent without usage context, an explanation of the 'product' scoping, or any hint about the 'view' mode's effect on results. For a listing tool with an openWorldHint, that is a meaningful gap.

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

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

Schema description coverage is 100% and the single 'view' parameter is self-documented in the schema, so the baseline is 3. The description adds nothing about the parameter and its 'one product' phrasing does not correspond to any input, so it neither helps nor fully compensates.

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?

It names a concrete resource (the account's saved events-page searches), which an agent can distinguish from get_event or search_events. But it is a bare noun phrase with no verb, and 'for one product' is vague since there is no product parameter and no indication of what the 'product' scoping means.

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 relation to sibling tools like search_events or list_filters. It also fails to mention the 'view' parameter's default or that this is a per-account listing.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive behavior, lowering the burden. The description adds valuable execution context beyond annotations: automatic paging until limit/history/10 pages, the reason short pages can still have more results, and the meaning of next_cursor.

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?

Front-loads the purpose in the first sentence, then explains paging and cursor continuation in a compact paragraph, ending with a useful pointer to get_event. Every sentence adds distinct value and there is no 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?

Given the 18-parameter schema and an output schema, the description supplies the key operational contract: how paging behaves, how to continue with next_cursor, and how to use event ids. It omits guidance on filter combination or auth/account requirements, but those are either schema-covered or non-critical for this read-only 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%, so the schema already documents all 18 parameters in detail. The description only adds the general framing that filters mirror the dashboard events page and mentions limit and cursor behavior, which is marginal beyond the schema.

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

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

States a specific verb and resource ('List events') with scope ('from the EyalSec account'), default ordering ('newest first'), and filter provenance ('same filters as the dashboard's events page'). This clearly distinguishes it from siblings like get_event (single event), event_stats, and event_counts.

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

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

Gives clear context for pagination continuation ('If next_cursor in the answer is not empty, call again with it') and points to get_event for per-event detail. It does not explicitly exclude sibling tools or say when another listing tool is preferable, but the intended use is unambiguous.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is fully covered by structured data. The description adds one genuine piece of context beyond that — no API key required — but says nothing about caching, freshness, or result size, which is acceptable at this lower bar.

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 resource scope and followed by the operationally relevant auth note. No filler sentences and nothing redundant with the schema.

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 an output schema present, return values need not be explained, and the description covers the content domain and the auth model. The only mild gap is that it never mentions the optional 'os' filter at the top level, though the schema covers it fully.

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

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

Schema description coverage is 100% and the single 'os' parameter is fully documented in-schema with an example value and its filtering effect. The description adds no parameter meaning beyond that, so the 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 names a specific resource set (Linux distributions, architectures, Python versions for es-python), so an agent knows exactly what data comes back. The verb is implicit (it is a lookup/listing tool) and there is no sibling differentiation, but no sibling overlaps this domain, so differentiation is not needed.

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 notes 'needs no API key', which is a useful operational hint, but never states when to call this versus any alternative or what scenario calls for it (e.g. before choosing an install target). The only conditional guidance ('list only the Python versions for it') 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.