bunny-net

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

Annotations already declare destructiveHint=true, and the description reinforces this with the leading 'WRITE' tag plus the undo tool reference, which is useful contextual framing. However it omits other behavioral details such as permission requirements, whether re-blocking an existing IP errors, or the mutation's effect scope.

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

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

Two compact sentences with the operation class ('WRITE') and the undo path front-loaded; every clause carries information and nothing is padded.

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

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

For a two-parameter destructive write with no output schema, the description covers what it does, that it mutates, and how to reverse it. It is nearly complete, missing only auth/error-behavior context that would make it fully self-sufficient.

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

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

Schema coverage is 100% and both parameters carry descriptions (IP format with example, pull zone ID constraint), so the schema does the heavy lifting. The description adds no parameter-level detail beyond what is already structured, 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 (Block) and resource (IP address on a pull zone), and explicitly names the inverse tool bunny_remove_blocked_ip, so an agent can distinguish it from siblings without opening a 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?

Gives clear context (blocking an IP from a pull zone) and points to the undo path via bunny_remove_blocked_ip, which effectively routes the agent to the paired tool. It stops short of stating exclusions, such as when blocking is inappropriate or what happens on duplicate entries.

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

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

destructiveHint=true already flags risk, and the description usefully adds that this is a WRITE that goes live immediately on production DNS, which is real context an agent won't get from the annotation alone. It still omits idempotency, permission/API-key requirements, and rate limits.

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

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

Three short fragments with the most decision-relevant word ('WRITE') front-loaded and zero filler. The trailing API-path line is informational rather than essential, keeping it just under the top band.

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

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

Covers the mutation and live-DNS consequence, but for a 14-parameter create with no output schema it says nothing about what comes back, and the returned record identifier is needed later by bunny_update_dns_record/bunny_remove_blocked_ip-style operations. Adequate but not complete.

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

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

Schema description coverage is 100% across all 14 parameters (ttl, priority, flags, weight, type enum, etc.), so the schema already carries full parameter meaning. The description adds no syntax, defaults, or type-conditional guidance beyond that, making the 3 baseline 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?

States a specific verb and resource ('Add a record to a DNS zone'), which is clearly distinct from bunny_list_dns_records and bunny_update_dns_record by the verb 'add' alone. It does not explicitly name or rule out those siblings, so it falls just short of the top band.

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 bunny_update_dns_record or bunny_export_dns_zone, and no stated prerequisites (e.g. the zone must already exist). The 'WRITE' marker and 'Takes effect on live DNS' warn of consequence but not of the conditions that select this tool.

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

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

Annotations already establish readOnlyHint=true, so safety is covered; the description adds the substantive behavioral detail that the payload is a plain-text BIND zone file rather than structured JSON, plus the underlying endpoint. It does not discuss size limits or pagination, but for a read-only export that is a minor omission.

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 plus the endpoint reference; the output format and the motivating use cases are front-loaded and nothing is wasted.

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

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

With no output schema, the description usefully discloses the return type (plain-text BIND zone file) and the mutation risk is nil per annotations. It is essentially complete for a single-parameter read tool, though it could note the response's non-JSON shape explicitly for downstream parsing.

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 there is a single parameter (zone_id), so the schema already carries the parameter meaning. The description adds no syntax, format, or lookup guidance for the ID beyond what the schema states, making the baseline 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?

States a specific verb (Export), a specific resource (one DNS zone), and the output format (BIND zone file, plain text). This clearly separates it from bunny_get_dns_zone and bunny_list_dns_records, which do not produce a zone-file export.

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

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

Gives concrete use cases — review, diffing, backup before a change — which tells the agent when this tool is the right pick. It stops short of naming alternatives (e.g. use get_dns_zone for JSON inspection), so it is not a full when/when-not routing statement.

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 readOnlyHint annotation already establishes safety, so the description's burden is lower. It still adds real value by disclosing the one-day temporal scope, the pagination mechanism, and the shape of the returned entries (including a diff), which goes beyond what the annotation conveys.

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

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

Three tight clauses, front-loaded with the core purpose, then pagination, then the endpoint. No sentence is redundant and nothing is buried.

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 read-only list tool with no output schema, the description covers the essential shape of the response and the pagination path, which is what an agent needs to call it correctly. It stops short of explaining filtering combinations, but the 100% schema coverage absorbs that 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 coverage is 100%, so every parameter is already documented in the schema, establishing the baseline of 3. The description reinforces the date scoping and the continuation_token pagination but adds no syntax, default, or filtering semantics beyond the schema text.

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 the account audit log') and adds a memorable framing ('who changed what on one day'). The enumerated return fields and the underlying endpoint (GET /user/audit/{date}) make its scope unmistakable and distinguish it from every sibling, none of which surface audit data.

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

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

It gives a useful operational hint ('Paginate with continuation_token') but no explicit when-to-use or when-not guidance. Since no sibling overlaps with audit-log retrieval, the usage is largely self-evident, but the description never states prerequisites or alternatives, leaving it at implied usage.

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

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

readOnlyHint=true already tells the agent this is a safe read, but the description adds genuinely useful context beyond the annotation: payment-method tokens are redacted, and it names the breakdown dimensions (traffic per continent, storage, DNS, Stream, scripting, Shield). It doesn't discuss rate limits or caching, so not a full 5.

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

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

One front-loaded sentence names the resource and its main returned fields, followed by the redaction note and the endpoint hint. The parenthetical product list is long but informative rather than filler; slightly dense though still efficient.

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

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

With no output schema, the description carries the return-value burden and does so reasonably, naming balance, per-product charges and recent billing records. Minor gaps remain about time window for 'recent' records and response shape, but the essentials an agent needs are present.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a no-param tool applies. No parameter guidance is needed or missing.

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 (billing) and enumerates the returned content: account balance, this-month charges broken down by product, and recent billing records. This clearly separates it from sibling read tools like bunny_get_statistics or bunny_get_audit_log.

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 name and the 'GET /billing' hint; there is no explicit statement of when to reach for this versus siblings such as bunny_get_statistics or bunny_get_audit_log. For a zero-parameter account-level read the intent is fairly self-evident, so this lands at minimum-viable rather than poor.

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 readOnlyHint=true already declaring the safe-read profile, the description adds the useful detail that the response bundles the zone's settings and records. It does not mention auth requirements, rate limits, or whether a missing ID errors — but the annotation already carries the safety burden.

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

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

Two compact sentences, front-loading the core purpose before the API mapping. Every clause earns its place with no padding.

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 single-parameter read whose annotations cover safety, the definition is nearly sufficient; 'with its settings and records' hints at the return shape even without an output schema, though nothing details nested record structure or error behavior.

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

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

Schema coverage is 100%, and zone_id is already documented as 'The DNS Zone ID.' The description adds nothing 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 (fetch) and resource (one DNS zone), plus what the payload contains (settings and records). The word 'one' distinguishes it from the sibling bunny_list_dns_zones, though no sibling is named explicitly.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no alternative is named. A caller must infer from 'one' that this is the single-zone retrieval vs. 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?

Annotations only cover the safety profile (readOnlyHint=true), so the description's disclosure that secrets (token-auth key, AWS signing secret, certificate private keys) are redacted is genuinely additive and prevents false assumptions about returned data. It also notes the underlying GET endpoint, aiding error interpretation.

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, zero filler. The high-value information (scope of returned settings, secret redaction) is front-loaded before the endpoint annotation.

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 compensates by enumerating the returned setting families, and it flags redaction and the edge-rule GUID linkage. Nothing an agent needs to call and interpret this read correctly appears to be 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 both parameters are already documented and the baseline is 3. The description reinforces certificate/secret handling but adds no syntax or format detail for include_certificate or pull_zone_id beyond what the schema provides.

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

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

States a specific verb and resource ("Fetch one pull zone") and enumerates the setting families returned, which cleanly separates it from the plural sibling bunny_list_pull_zones. An agent can distinguish the two without opening either 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?

Gives clear retrieval context and a workflow hook by noting the edge-rule GUIDs are 'needed by bunny_set_edge_rule_enabled', which tells the agent how this tool chains into a mutation. It stops short of explicit when-not guidance (e.g. using list_pull_zones to discover the ID first).

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?

readOnlyHint=true already covers the safety profile, but the description adds real value by disclosing the API method (GET /statistics) and, crucially, the shape of the returned data (summary metrics plus optional charts) that no output schema provides. It does not mention rate limits or auth, so it stops short of a 5.

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

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

Front-loaded with the core purpose and scope, then the metric/chart inventory, ending with the endpoint. Dense but every clause carries information; only the lengthy chart enumeration makes it slightly list-heavy.

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 readOnlyHint and full schema coverage, the main gap is the return payload, which the description addresses by naming the metrics and chart categories. Missing only output structure and any aggregation/pagination behavior, so it is nearly complete for a read-only statistics 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 every parameter (dates, hourly, region_id, pull_zone_id, load_* flags) is already documented in the schema. The description restates chart and scope concepts but adds no format or default detail 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+resource (get CDN statistics) and enumerates the returned metrics (bandwidth, origin traffic, requests, cache hit rate, response time) and scope (account or a single pull zone). The 'CDN' framing implicitly separates it from bunny_get_storage_zone_statistics, so an agent can place it without opening a 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?

The 'account or one pull zone' phrasing implies the scoping decision, but there is no explicit when-to-use guidance, no exclusions, and no named alternative (e.g. bunny_get_storage_zone_statistics for storage zones, which is a genuine sibling). Usage is inferable rather than stated.

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

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

Annotations only supply readOnlyHint=true, and the description usefully adds the redaction behavior ('Storage passwords are redacted') and the underlying endpoint, which is real behavioral context beyond the annotations. It stops short of noting error/not-found behavior or permissions, but for a read-only fetch the disclosure is solid.

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

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

Two compact sentences, the resource and its returned fields front-loaded, no filler. Every clause (field list, redaction note, endpoint) 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?

With no output schema, the description compensates by enumerating the returned fields, and it flags the redaction behavior an agent should expect. For a single-entity read-only fetch, nothing needed to call 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?

There is a single parameter with 100% schema description coverage, so the schema already documents storage_zone_id. The description adds nothing about format or constraints, but the 'GET /storagezone/{id}' mapping confirms the ID is a path identifier. Baseline 3 applies 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?

Specific verb ('Fetch') plus a clearly scoped resource ('one edge storage zone'), and it enumerates the returned fields (hostname, region, replication, storage used, 404 handling, connected pull zones). The singular 'one' cleanly distinguishes it from the sibling list tool bunny_list_storage_zones and from bunny_get_storage_zone_statistics.

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 word 'one' implies single-item retrieval as opposed to listing, and the API endpoint mapping reinforces it, but the description never explicitly names an alternative or states when to prefer this over bunny_list_storage_zones or bunny_get_storage_zone_statistics. Usage is implied rather than guided.

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?

readOnlyHint=true already establishes this is a safe read. The description usefully adds that results are daily-granularity charts and maps to a specific API endpoint, but says nothing about pagination, response shape, or how large date ranges affect payload size.

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

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

Two compact sentences with the return content front-loaded and the API mapping appended. Nothing is redundant or padded.

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 does the work of stating what comes back (daily charts of usage and file count). It is nearly complete for a simple read tool; the only gap is not addressing the default date window or result volume, which the schema partially covers.

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 date_from/date_to formats, defaults (omit both for last 30 days), and the required storage_zone_id are all fully documented in the schema. The description adds no parameter meaning 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 specific resource (storage used and file count for one storage zone) and the granularity (daily charts), plus the underlying GET endpoint. It is clear what the tool returns, though it never distinguishes itself from the sibling bunny_get_statistics, which is the most likely confusion point.

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 guidance. An agent must infer that this is the storage-zone-specific counterpart to bunny_get_statistics, and nothing in the description resolves that overlap or states prerequisites such as needing a valid storage zone ID.

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

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

Annotations already declare readOnlyHint=true, so safety is covered. The description adds real behavioral context by disclosing that API keys are redacted and naming the configuration groups returned (resolutions, DRM, referrer rules, transcribing, watermark), which an agent cannot get from annotations or the minimal 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?

One front-loaded sentence carries the purpose and the most decision-relevant fact (redaction), followed by a short endpoint reference. Dense and mostly waste-free, though the raw API route is marginal for an agent.

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 usefully enumerates what comes back and flags the redaction caveat, which is exactly the gap structured fields leave. Only minor omissions remain, such as error behavior for an invalid or unauthorized library_id.

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 a single well-documented library_id, so the schema carries parameter semantics. The description adds nothing beyond identifying which library is fetched, which is the correct baseline for full 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?

States a specific verb (Fetch) and a precisely scoped resource (one Stream video library), with the returned configuration enumerated. The word 'one' plus the sibling bunny_list_video_libraries makes the singular/plural distinction clear without opening either 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?

The phrase 'Fetch one ... library' implies retrieval of a single known ID, which implicitly separates it from the list tool, but no alternative or condition is named explicitly. Usage is inferable rather than stated.

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

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

readOnlyHint=true already marks this as a safe read, and the description adds genuinely useful behavior beyond that: the returned record type is an integer code, with the full code-to-type mapping spelled out. It also names the upstream endpoint. It stops short of describing pagination behavior or response shape.

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

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

Front-loaded with the core action, then the response-encoding caveat, then the API reference. The 16-entry code list is bulky but earns its place since no output schema exists to document the encoding 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?

With no output schema, the description carries the burden for return semantics; it usefully documents the record-type encoding but says nothing about the record object fields, pagination/max-results behavior for the page and per_page params, or default page size. Adequate but incomplete for a 5-parameter paginated list.

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 baseline is 3, but the description goes further by documenting the integer encoding returned for record types — information the string-valued enum in the schema does not convey. It does not clarify page/per_page semantics 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 with explicit scope ('List the records in one DNS zone'), which clearly separates it from the zone-level siblings like bunny_list_dns_zones and bunny_get_dns_zone. It does not name an alternative directly, but the resource boundary 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?

Says the listing can be 'optionally filtered by type or search term', which implies the filtering use case, but gives no when-to-use/when-not guidance and never points to bunny_export_dns_zone or bunny_get_dns_zone as alternatives. Usage must be inferred.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds the useful detail that results carry nameserver detection, DNSSEC and logging status, but says nothing about pagination behaviour, result ordering, or what happens for accounts with many zones.

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-loads the verb and resource, followed by the endpoint reference. Both earn their place, though the 'bunny.net: GET /dnszone' tag is mildly redundant for an agent that only needs 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?

For a read-only paginated list tool with no output schema, the description covers what is listed and what fields matter. It is nearly complete; only pagination semantics and the list-vs-get distinction are 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?

Schema coverage is 100% and all three parameters (page, search, per_page) are documented in the schema with defaults and ranges. The description adds no parameter meaning 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?

States a clear verb+resource ('List the DNS zones hosted on bunny.net') and enumerates the interesting fields returned (nameserver detection, DNSSEC, logging status). It implicitly distinguishes itself from the singular bunny_get_dns_zone and from bunny_list_dns_records, 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?

The listing scope implies when to use it, and 'hosted on bunny.net' hints at account-wide listing, but there is no explicit when-to-use guidance, no mention of alternatives like bunny_get_dns_zone for a single zone, and no prerequisites 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?

readOnlyHint=true already declares the safe-read profile, so the bar is lower; the description nonetheless adds real value by enumerating what the compact view contains (id, name, origin URL, enabled/suspended, hostnames, linked storage zone, bandwidth, charges) and what full=true expands. It does not mention pagination limits at the tool level, but the schema covers those.

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-loaded with the core action, followed by the one behaviorally important distinction (compact vs full) and the API endpoint. The inline field enumeration is slightly dense but each item earns its place by describing the default payload.

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 adequately conveys what comes back and how to widen it. Pagination and filtering semantics are fully covered by the schema, leaving no significant gap for an agent 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 100%, so a 3 is the baseline, but the description goes beyond it by spelling out the difference between the compact and full response modes, which gives the boolean `full` concrete meaning. The page/search/per_page parameters are left entirely to 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 (List) and resource (CDN pull zones on the account), plus the underlying API endpoint (GET /pullzone). This cleanly distinguishes it from bunny_get_pull_zone (single zone) and the other bunny_list_* siblings for storage zones and DNS zones.

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

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

Explains the default compact response and when to set full=true, which is useful operational context, but never names alternatives or states when to prefer this over bunny_get_pull_zone or bunny_get_billing. Usage is implied rather than 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?

The readOnlyHint annotation already establishes this as a safe, non-destructive operation. The description adds useful behavioral context beyond that: it is a cheap credential check and returns IDs, codes, location, and per-GB pricing. It does not discuss errors or pagination, but for a simple read-only list this is sufficient.

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

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

Two sentences plus a compact endpoint reference. The purpose is front-loaded, the return fields are listed efficiently, and every sentence adds specific value without 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 zero-parameter, read-only list operation with no output schema, the description supplies enough detail: the resource, returned fields, a credential-check use case, and the underlying API endpoint. An agent can select and invoke it correctly without further context.

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

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

The tool takes zero parameters, so there are no parameter semantics to document. Per the scoring rule, a 0-parameter tool with an empty schema has a baseline of 4; the description correctly avoids unnecessary parameter discussion.

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 bunny.net's edge regions') and immediately enumerates the returned fields, so the agent knows exactly what this tool does. It is clearly distinct from all sibling tools, which cover DNS, storage, billing, purge, and other resources.

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

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

Provides an explicit practical use case: 'A cheap way to confirm the API key works.' This gives clear context for when to call it, though it does not state exclusions or compare against alternatives, which is minor given that no sibling lists regions.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered; the description goes beyond that by disclosing that storage passwords are redacted and by naming the underlying endpoint (GET /storagezone). It stops short of describing pagination behavior or what the response envelope looks like, but the redaction note is real added value.

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

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

A single front-loaded sentence enumerating the returned fields, followed by the redaction caveat and endpoint reference. Every clause earns its place with 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 no output schema, the description compensates by enumerating the returned fields and flagging password redaction, and annotations plus schema cover safety and pagination. Only minor gaps remain, such as whether the search term matches zone name only and how deleted zones behave in 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 description coverage is 100% and all four parameters (page, search, per_page, include_deleted) are documented in the schema itself. The description adds no semantics 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?

States a specific verb (list) and resource (edge storage zones on the account) and even enumerates the fields returned: region, replication regions, storage used, file count, tier, connected pull zones. This clearly separates it from the singular bunny_get_storage_zone and from unrelated siblings like bunny_list_regions.

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

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

Usage is implied by 'on the account' (list everything, no filtering context stated) but the description never says when to prefer this over bunny_get_storage_zone for a single zone, nor how pagination/search parameters interact with usage. Adequate but leaves the alternative unstated.

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 establish readOnlyHint=true, so the safety profile is covered. The description adds genuinely useful context beyond that: it names the fields returned and discloses that 'Library API keys are redacted', a security-relevant behavioral trait not visible in the 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 dense sentence front-loads the verb and resource, then lists return contents, and ends with the API endpoint. Nothing is wasted, though the enumerated field list makes it slightly heavy for a one-line definition.

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 usefully summarizes the returned fields, and annotations cover the read-only nature. Pagination and filtering are handled by the fully-described schema, so the agent has what it needs; only routing guidance against siblings 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 page, search, and per_page are fully documented in the schema with defaults and bounds. The description adds nothing about these parameters, so the baseline of 3 applies rather than a higher mark.

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 (Stream video libraries), and enumerates the data returned: video count, storage/traffic usage, linked pull/storage zones, player and encoding settings. This distinguishes it from the singular sibling bunny_get_video_library and from bunny_list_pull_zones or bunny_list_storage_zones.

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 verb 'List' – there is no explicit when-to-use guidance or statement of when to prefer this over bunny_get_video_library for a single library. The agent can infer the plural/singular split from the sibling names, but the description does not route it.

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

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

Annotations already flag destructiveHint=true, so the bar is lower, yet the description adds real value: it marks this as a WRITE, clarifies that nothing is permanently lost because the CDN refetches from origin, and warns that the origin absorbs the refill load. It stops short of permission or rate-limit details.

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

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

Front-loaded 'WRITE.' marker, then the effect, then the trade-off, then the API endpoint — no sentence 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 two-parameter mutation with no output schema and annotations covering destructiveness, the description supplies the missing consequence narrative. Only auth/prerequisite context is absent, which is a minor gap.

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

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

Schema coverage is 100%, so both parameters are already documented, and cache_tag's meaning is repeated rather than extended. Baseline 3 is appropriate given 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 ('Purge the cached content of one pull zone') with explicit scope ('everything, or only files carrying a cache tag'). This differentiates it from the sibling bunny_purge_url, which operates on a URL rather than a whole zone.

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

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

The description explains the two purge modes and their trade-off, which implies when each is appropriate, but it never names the alternative tool (bunny_purge_url) or states when not to purge a whole zone. Usage is inferable but not spelled out.

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

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

Annotations only supply destructiveHint=true, so the description carries real weight and delivers: trailing-slash purges everything beneath the path unless exact_path is true, wildcards are accepted, and the CDN refetches from origin. It stops short of stating irreversibility, propagation delay, or rate limits, keeping it below 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?

Three tight sentences, front-loaded with the write classification and the core action, then the scoping edge cases, then the API mapping. 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 3-parameter mutation with no output schema and full schema coverage, the description covers behavior, edge cases, and the upstream endpoint. Only the absence of any statement about propagation or permanence of the purge keeps it from being fully complete.

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

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

Schema coverage is already 100%, so the baseline is 3, but the description adds genuine nuance by explaining the interaction between a trailing '/' and exact_path, plus wildcard support -- semantics the schema alone does not spell 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 and resource ('Purge one URL from the CDN cache') plus a scoping restriction ('one URL'), which cleanly separates it from the zone-wide sibling bunny_purge_pull_zone_cache. The leading 'WRITE' label signals the operation class immediately.

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 word 'one URL' implies this is the single-URL purger rather than the zone-wide purge, but the alternative (bunny_purge_pull_zone_cache) is never named and no explicit when-to-use/when-not guidance is given. Usage is inferable from scope but not 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?

With only destructiveHint=true and a title in the annotations, the description adds useful context: it confirms this is a write operation and maps it to the non-obvious POST /pullzone/{id}/removeBlockedIp endpoint. However it omits the real side effect — that unblocking lets previously blocked traffic reach the zone — plus idempotency and error behavior when the IP is absent, which is exactly the context a caller of a destructive write needs.

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

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

Three tightly packed fragments: the mutation marker, the action, and the raw API route. Everything is front-loaded and nothing is wasted.

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

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

For a simple two-required-parameter tool with full schema coverage, no output schema, and a destructiveHint annotation, the description covers the essentials. The remaining gap is the absence of any note about the consequence of unblocking or authorization requirements, which would be nice but is not strictly 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 100% (both ip and pull_zone_id are documented in the schema), so the schema carries the parameter burden. The description adds no format, range, or constraint detail beyond what the schema already states, 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 gives a precise verb+resource ('Remove an IP address from a pull zone's block list') and the 'WRITE' marker signals the mutation category, which cleanly separates it from the read-side siblings. It does not explicitly name bunny_add_blocked_ip, but the 'remove from block list' semantics make the inverse relationship 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?

There is no guidance on when to call this versus alternatives, no prerequisite (e.g. the IP must already be on the block list), and no exclusions. The 'WRITE' prefix hints at mutation context but is a category label rather than usage advice.

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

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

Adds real context beyond the annotations: it states the change is reversible and the rule is preserved rather than deleted, and it names the underlying endpoint POST /pullzone/{pullZoneId}/edgerules/{edgeRuleId}/setEdgeRuleEnabled. The 'reversible' framing sits in mild tension with destructiveHint=true, but a state toggle is still a config-modifying write, so this is a useful nuance rather than a contradiction.

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

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

Three dense sentences, front-loaded with the write classification and core action, followed by prerequisite and endpoint. No filler, nothing repeated from 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?

For a three-parameter toggle with full schema coverage and annotations present, the description covers classification, reversibility, prerequisite lookup, and endpoint. The only omission is what the call returns, which is minor given no output schema is defined and the operation is a simple state change.

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 baseline would be 3, but the description adds derivation info the schema lacks: where to obtain edge_rule_id (EdgeRules[].Guid from bunny_get_pull_zone). That is genuine added meaning for the one parameter an agent is most likely to get wrong.

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 ('Turn one edge rule on a pull zone on or off') with clear scope ('one'), plus a 'WRITE' category marker. No sibling tool touches edge rules, so the agent can identify the target operation unambiguously.

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 routes the agent to bunny_get_pull_zone for the required edge_rule_id GUID, which is the practical prerequisite for calling this tool. It does not give when-not-to-use conditions or name an alternative toggle path, but the retrieval prerequisite is the main guidance an agent needs.

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

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

Annotations only declare destructiveHint=true; the description adds meaningful context beyond that: it opens with 'WRITE', states the change 'Takes effect on live DNS', and the keep-the-fields-you-want instruction implies full-replacement (PUT-style) semantics rather than a partial patch. It stops short of stating auth requirements or irreversibility explicitly.

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-loaded with the 'WRITE' marker, followed by purpose, effect, workflow, and endpoint in four tight sentences. Every sentence carries distinct information with no redundancy.

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

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

For a 15-parameter mutation tool with no output schema, the description covers the essentials: write nature, live impact, read-before-write flow, and API mapping. It leaves return-value behavior unstated, but with no output schema that is a minor gap.

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

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

Schema description coverage is 100%, so all 15 parameters are already documented in the schema (including type-specific usage for flags, port, priority, etc.). The description only echoes the required type/name/value trio and adds no per-parameter meaning, so 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 verb+resource ('Update an existing DNS record') and scopes it to existing records, which implicitly separates it from bunny_add_dns_record. The live-DNS impact statement sharpens the purpose. It does not explicitly contrast against the add sibling, keeping it at 4 rather than 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?

Gives an explicit workflow prerequisite: read the record first with bunny_list_dns_records and carry over fields you want to keep. This is actionable when-to-use guidance with a named alternative. No explicit when-not-to-use or guidance against bunny_add_dns_record, so not a 5.

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