StatusPal MCP by usefulapi

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

Annotations only carry destructiveHint=true, but the description adds real consequence context: the incident is published to a LIVE public page and notify=true emails subscribers. That tells the agent the action is externally visible and hard to walk back. It does not cover reversibility, permissions, or rate limits, 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?

Three short sentences, front-loaded with the verb and the most decision-relevant fact (live public publication plus notify behavior). The type-semantics sentence duplicates the schema, which is minor waste but keeps the whole definition scannable.

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 create tool with no output schema, this covers the key question an agent faces: what publishing actually does and who gets notified. It omits auth/permission requirements and what the call returns, but nothing is actively misleading or missing from the schema.

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

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

Schema coverage is 100%, so every parameter is already documented in the schema, including the same type and notify semantics the description restates. The description adds essentially no syntax or format detail beyond structured data, 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?

The description states a specific verb and resource with its blast radius: 'PUBLISHES a new incident to the LIVE public status page'. 'New incident' implicitly separates it from statuspal_create_incident_update and statuspal_update_incident. It stops short of naming a sibling explicitly, so it falls just under the top tier.

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: you call it when you need a new incident published, and the 'LIVE public status page' framing hints that it is externally visible. There is no explicit when-not guidance or routing to update_incident for existing incidents, nor any prerequisite/permission note.

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 behavioral context beyond the bare destructiveHint annotation: the write lands on a LIVE public status page (public exposure), notify=true fans out emails to subscribers, and the full REST endpoint is given. Missing details like whether updates are immutable/append-only or any rate limits keep it short of 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 dense, front-loaded sentence carries purpose, visibility, notification behavior and endpoint with zero 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 mutation with no output schema, the description covers what it does, where it lands, and the notification side effect, which is enough to call it correctly. It omits error/state-transition behavior and irreversibility of subscriber emails.

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 six parameters are already documented. The description restates notify=true and gives lifecycle examples for type, but that largely duplicates the schema's own 'common values' list rather than adding new syntax or constraint detail.

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

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

States a specific verb and resource ('POSTS an update ... to an existing incident') and names the affected surface (LIVE public status page), with the lifecycle stages enumerated. It stays clearly distinct from statuspal_create_incident, though it never explicitly contrasts itself with statuspal_update_incident.

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?

Clearly frames the usage context: adding a lifecycle update to an already-existing incident, with notify=true as the subscriber-notification path. No exclusions or explicit alternative routing (e.g., use update_incident to change incident fields) are stated.

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

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

Annotations only flag destructiveHint=true, whereas the description adds the two facts an agent actually needs: the deletion hits the LIVE public page and is permanent/irreversible. That is real added context beyond the annotation, though it still says nothing about auth requirements, error behavior, or whether related update records are cascaded.

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 ALL-CAPS verb and the consequence, then the API route. The redundancy between 'DELETES' and 'permanently removes it' is defensible emphasis for a destructive operation, but it is still two clauses making the same point.

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 2-parameter, no-output-schema destructive tool, the description plus the destructiveHint annotation cover the essential decision inputs: what is destroyed and that it is irreversible. Remaining gaps (side effects on incident updates, failure modes) are minor and typical for a CRUD delete.

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 subdomain (with its STATUSPAL_SUBDOMAIN override semantics) and incident_id are documented there. The description's endpoint path merely mirrors those parameters without adding format, range, or lookup guidance, 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 (DELETE) and resource (incident) and names the exact surface affected — the LIVE public status page — plus the underlying API route. It is immediately distinguishable from the create/update/get/list siblings that operate on the same resource.

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

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

Deleting is self-evidently the tool's job, so usage is implied, but there is no explicit guidance on when to reach for it versus statuspal_update_incident, nor any prerequisite (permissions, confirming the incident is not scheduled/resolved) or warning about what happens to linked incident updates.

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, so the description carries a lighter burden. It adds the underlying REST route (GET /status_pages/{subdomain}/incidents/{incident_id}), which is mildly useful context, but says nothing about 404 handling or the shape of the returned incident.

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

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

Two short sentences with the core action front-loaded and no filler. The endpoint restatement is slightly redundant but not wasteful enough to penalize heavily.

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

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

For a simple single-resource read with fully documented parameters and annotations covering the safety profile, the description is essentially sufficient. No output schema exists, so no return-value explanation is owed, though a note on not-found behavior would round it out.

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%, with both subdomain and incident_id described in the schema, so the baseline is 3. The description adds no syntax, format, or override semantics beyond what the schema already documents.

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 a single incident by its id'), making it distinguishable from the list-style sibling statuspal_list_incidents. It stops short of explicitly naming the sibling it contrasts with, so it is clear but not fully differentiated.

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

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

Usage is only implied: the id-based lookup signals 'fetch details for one known incident.' There is no statement of when to prefer this over statuspal_list_incidents or statuspal_get_status, and no mention of preconditions or error behavior for a missing 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?

The readOnlyHint annotation already establishes this is a non-mutating read, so the description is not carrying the safety burden. It adds the concrete API route (GET /status_pages/{subdomain}/services/{service_id}/status), which confirms the read semantics and path shape, but says nothing about return content, freshness, or caching.

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

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

Two short sentences with the purpose front-loaded and no filler. The trailing endpoint reference is somewhat redundant with the name and schema but is compact enough to be tolerable.

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 would ideally say what 'current status' contains (state, uptime, incident linkage). It stops at the endpoint, leaving the response shape for the agent to discover. Adequate but with a clear gap for a status-retrieval tool.

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

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

Schema description coverage is 100%, with both subdomain and service_id documented in the schema, so the baseline is 3. The description adds only that the lookup is 'by its id'; it does not explain the subdomain override behavior already noted in the schema.

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

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

States a specific verb (Get) and resource (the current status of a single service) scoped by id, which sets it apart from the fleet-level siblings such as statuspal_list_services. It does not explicitly distinguish itself from statuspal_get_status, so the sibling differentiation is only implied.

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 'a single service by its id' implies the case where you already have a service_id, and by contrast implies statuspal_list_services is used to discover ids. However, there is no explicit when-to-use statement or named alternative, and the overlap with statuspal_get_status is left unaddressed.

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, non-mutating read, so the description is not carrying the safety burden. What it adds is the underlying REST mapping (GET /status_pages/{subdomain}/status), which is developer-oriented rather than behaviorally informative; it says nothing about the shape of the returned status 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?

Two short sentences, front-loaded with the purpose and followed by the API path. Nothing is wasted, though the endpoint string is of marginal value to an agent choosing a tool.

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

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

For a trivial read tool with one optional parameter and a safe read annotation, the description covers what is needed to call it. Without an output schema it could briefly say what the aggregate status returns, but that is a minor gap given the tool's simplicity.

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

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

With a single parameter and 100% schema description coverage, the schema already documents subdomain fully, including that it overrides STATUSPAL_SUBDOMAIN. The description adds no syntax, format, or fallback detail beyond that, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Get the current overall status of the status page') and adds scope qualifiers ('overall', 'aggregate status type') that distinguish it in spirit from statuspal_get_service_status. It never names a sibling explicitly, so differentiation still requires the agent to compare names.

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 parenthetical 'aggregate status type' implies this is the page-wide rollup rather than a per-service check, which nudges the agent away from statuspal_get_service_status. However, there is no explicit when-to-use statement, no condition selecting this over statuspal_get_summary, and no exclusions.

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

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

Annotations declare readOnlyHint=true, so the safety profile is already covered. The description adds real context beyond that: it discloses the full return payload shape and the underlying endpoint (GET /status_pages/{subdomain}/summary). It does not mention auth requirements, rate limits, or payload size/caching behavior, so it is solid but not rich.

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 elements: a front-loaded purpose sentence with the full return inventory, then the endpoint reference. Nothing is redundant, and the field list earns its place because no output schema exists.

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 compensates by enumerating every returned field, and the one optional parameter is fully documented in the schema. Missing minor details — whether the response can be large, any caching, or auth expectations — keep it short of a 5.

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

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

Schema description coverage is 100% and the single subdomain parameter is already documented there (including the STATUSPAL_SUBDOMAIN override). The description only echoes the parameter via the endpoint template, adding no new semantics — the baseline 3 applies when 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 verb (Get) and resource (status-page summary) and enumerates the exact contents returned — status_page, services[], incidents[], maintenances[], upcoming_maintenances[], info_notices[], current_status_type. That enumeration implicitly separates it from siblings like statuspal_list_incidents or statuspal_list_services, but it never explicitly contrasts with statuspal_get_status or statuspal_get_service_status, so differentiation is inferential rather than stated.

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

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

There is no explicit when-to-use or when-not-to-use statement, and no sibling is named as an alternative. The word 'FULL' weakly implies this is the one-shot aggregate call versus the granular list/get siblings, but that is an inference the agent must make on its own.

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. Beyond that, the description discloses the return envelope ({incidents[], links:{next,prev}, meta:{total_count}}), which matters because no output schema exists, and it clarifies cursor-based pagination semantics. It doesn't mention rate limits or auth requirements, but the added return-shape context is real 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?

Three tight sentences: purpose first, then return shape, then parameter usage plus endpoint mapping. No filler and nothing 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 a five-parameter read tool with no output schema, the description supplies the missing return structure and pagination story, which is what an agent most needs. Auth/subdomain resolution nuance is left to the schema, 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 five parameters are already documented in the schema. The description restates the before/after pagination role and the type filter without adding format, allowed values, or interaction rules (e.g. can before and after be combined). Baseline 3 applies when 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 verb+resource (list incidents) scoped to a status page, which distinguishes it from the write siblings (create/update/delete_incident) and from get_incident's single-record scope. It does not explicitly name the alternative for single-record retrieval, so it stops just short of full sibling differentiation.

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

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

The description gives operational guidance on how to use parameters ('use before/after cursors to paginate and type to filter') but never states when to reach for this tool versus get_incident or the other list_* tools. Usage is implied rather than explicitly framed.

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 description only needs to add context beyond that. It notes the pagination mechanism and maps to the underlying GET endpoint, which is modestly useful, but says nothing about result ordering, page size defaults, or empty-result behavior. Adequate but thin on top of the annotation.

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 sentences, front-loaded with the core purpose and free of filler. The trailing endpoint reference is mildly redundant for an agent that already has the tool name, but it is short and does not bloat the 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?

For a no-required-param, read-only list tool with fully documented schema and no output schema, the description covers what is needed to invoke it correctly. Pagination is acknowledged and the safety profile is carried by annotations; only return-shape details are absent, which is minor 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?

Schema description coverage is 100%, so all four parameters (after, limit, before, subdomain) are already documented in the schema. The description's mention of before/after cursors repeats what the schema says without adding format or interaction detail. 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?

States a specific verb and resource: 'List the metrics configured on a status page.' An agent can distinguish this from the incident/service siblings since the resource (metrics) is unique. It stops short of explicitly contrasting with any sibling, but the purpose itself 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?

The only guidance given is 'Use `before`/`after` cursors to paginate,' which is parameter mechanics rather than when-to-use guidance. There is no statement of when this tool is appropriate versus the sibling list/get tools, nor any prerequisites or exclusions.

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

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

readOnlyHint=true already tells the agent this is a safe read, so the bar is lower; the description still adds value by naming the underlying endpoint (GET /status_pages/{subdomain}/services) and by describing the returned fields, which matters since no output schema exists. It does not cover pagination or rate limits, but the core behavior is disclosed.

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

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

One tight sentence stating purpose and return shape, followed by a compact endpoint reference. Nothing is wasted and the key information is front-loaded.

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

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

For a simple read-only list tool with no output schema, the description supplies the return shape and the backing endpoint, which is enough for correct invocation. Only minor gaps remain (pagination, empty-list behavior, whether children are recursive).

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 single subdomain parameter is fully documented in the schema, including that it overrides STATUSPAL_SUBDOMAIN. The description adds no syntax or format detail beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource ('List the services on a status page') and goes further by enumerating the returned shape {id, name, current_incident_type, children[]}. This clearly separates it from siblings like statuspal_get_service_status (single service) and statuspal_list_incidents.

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

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

Usage is implied by the verb and resource, but there is no explicit statement of when to choose this over statuspal_get_service_status or statuspal_list_incidents, nor any precondition noted. An agent can infer the context but receives no 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?

The annotation destructiveHint=true already signals a mutating operation, and the description adds the useful context that changes hit the LIVE public status page. However, it omits important behavioral details for an update: whether omitted fields stay unchanged, what notify actually does, and any auth/permission requirements.

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, front-loaded with the action and scope before the API path. No filler, though the parenthetical field list is somewhat 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?

For an 8-parameter mutation tool with no output schema, the description covers purpose and affected fields but leaves gaps around partial-update semantics (which fields change when omitted), the notify behavior, and the fact that the endpoint is a PUT. 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%, so the schema already documents all 8 parameters, including the enum for type and the ISO8601 formats. The description lists the field groups (title/type/services/timing) but adds no syntax or semantics beyond the schema, 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 (UPDATES) and resource (existing incident) and names the fields affected (title/type/services/timing), plus the endpoint. It distinguishes itself from create/delete siblings via 'existing incident', but never explicitly contrasts with the close sibling statuspal_create_incident_update, so differentiation is inferred rather than stated.

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

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

The description implies the tool is for modifying an existing incident but gives no explicit when-to-use guidance, no exclusions, and no reference to alternatives such as create_incident_update or create_incident. The agent must infer the routing decision from the name alone.

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