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

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=true, idempotentHint=false, openWorldHint=true), and the description does not contradict them. It adds one genuine behavioral fact beyond annotations: the stream key is redacted by default. However it omits other relevant traits such as permission/plan prerequisites and what the created stream's lifecycle looks like.

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

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

Two short sentences with no filler, and the core action is front-loaded. Every sentence earns its place, including the note about default key redaction.

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

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

With an output schema present and annotations covering safety, the description need not explain return values, and those gaps are covered. But for a moderately complex creation tool it leaves the agent without usage context: no indication of required campaign/permission prerequisites, no distinction from update_live, and the 'early-access' qualifier is left unexplained.

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 detailed enum and per-field docs (state semantics, ISO 8601 scheduled_for, include_stream_key, live_access_rule_ids), so the schema carries parameter meaning fully. The description only echoes the stream-key redaction behavior, which duplicates the include_stream_key documentation, 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?

States a specific verb and resource: 'Create an early-access Patreon Live livestream.' The verb naturally separates it from the sibling read/update tools (get_live, update_live), but the description never names or contrasts those siblings explicitly, 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?

There is no when-to-use guidance at all: nothing says when to pick create_live over update_live, what campaign/permission context is required, or what 'early-access' means for eligibility. The one routing hint ('fetch it with get_live(include_stream_key=true)') lives in the schema, not in the description.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true and openWorldHint=true, and the description is consistent with them while adding genuine behavioral context beyond structured data: it requires a session cookie, uses an undocumented browser API that can break, and supports only text posts. This is exactly the operational disclosure an agent needs for a fragile write tool.

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

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

Three tight sentences, front-loaded with purpose, then prerequisites, then the API fragility warning and scope limit. Every sentence earns its place with no repetition of schema content.

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

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

With an output schema present, annotations covering safety, and 100% schema coverage, the description supplies the remaining critical context: authentication requirements and the fact that this uses a fragile undocumented browser API. Nothing essential is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so all ten parameters are already documented in the input schema. The description adds only the 'text posts' limitation, which touches the content parameter but otherwise does not extend parameter meaning. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description names a specific verb and resource ('Create a text post') and scopes it precisely ('through Patreon's web editor API', 'Only text posts are supported'). This distinguishes it from publishing or updating posts without needing to open the schema.

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

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

It states a precondition (requires PATREON_SESSION_COOKIE or PATREON_SESSION_COOKIE_FILE) and contrasts with the official OAuth API, but it never says when to choose this tool over siblings like create_live or publish_post, nor when not to use it. 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?

Annotations already declare destructiveHint=true, openWorldHint=true, idempotentHint=false and readOnlyHint=false, so the safety bar is covered. The description adds genuinely useful context beyond that: the response carries an HMAC signing secret, it is gated by an allow-list env var, and it constitutes a persistent data-export channel requiring approval.

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

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

Front-loads the core action in the first sentence, then adds the two most decision-relevant caveats (host allow-list gating, approval advisory) in short lines. No wasted filler, though it is terse enough that the caveats read as fragments.

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

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

An output schema exists so return values need not be spelled out, and annotations cover the safety profile. The description supplies the non-obvious operational constraints (allow-list gating, approval, secret in response), leaving little an agent needs missing for correct invocation.

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

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

Schema description coverage is 100%, so the schema fully documents uri, triggers, and campaign_id, and the description contributes no additional parameter meaning. Baseline 3 is appropriate 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 ('Create a webhook') and notes the salient output (HMAC signing secret). It is clearly distinct from siblings like update_webhook and delete_webhook by virtue of the create verb, though it does not explicitly name them.

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

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

Provides a precondition ('Disabled unless PATREON_WEBHOOK_ALLOWED_HOSTS permits the target host') and an advisory ('clients should require approval'), which implies when this is usable. However, it never explicitly says when to use this versus list_webhooks/update_webhook or otherwise routes the agent among alternatives.

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

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

The annotations already declare destructiveHint=true, idempotentHint=true, openWorldHint=true, and readOnlyHint=false, so the safety profile is fully covered structurally. The description's 'destructive and cannot be undone' restates destructiveHint, though naming the web editor API endpoint adds minor context. No further behavioral detail (permissions, effect on published vs draft posts) 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?

Two short sentences, both front-loaded on the action, with the destructive warning immediately following. Nothing extraneous and no repetition of the title.

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 mutation with an output schema present (so no return-value explanation needed) and annotations covering the safety profile, the description is nearly sufficient. It could still note whether published posts or only drafts are deletable, but the core is 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% and the single post_id parameter is documented in the schema as 'Patreon post ID.' The description adds no extra meaning 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 ('Delete') and resource ('a post'), and the 'web editor API' qualifier pins down which API surface. Among the siblings, it is unambiguously the deletion counterpart to create_post/update_post/publish_post.

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

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

No when-to-use guidance, prerequisites, or alternatives are given. The warning that the action is irreversible is a caution, not routing guidance for choosing this tool over update_post or equivalent siblings.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, so safety and repeat-call behavior are covered. The description's one added value is the ownership scope ('created by this API client'), but it says nothing about permanence, confirmation, or side effects on deliveries beyond what annotations provide.

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

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

A single front-loaded sentence with no filler; the scope qualifier is positioned right after the verb-resource pair. It is tight but so terse that it verges on under-specification.

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

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

An output schema exists, so return values need no explanation, and there is only one required parameter. Annotations carry the destructive/idempotent profile. The only gap is the absence of confirmation or irreversibility wording, which is minor given destructiveHint.

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% for the single required webhook_id parameter, so the baseline is 3. The description does not clarify whether the ID is the API-level webhook ID or an external provider ID, adding no meaning 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?

Specific verb (Delete) plus resource (webhook), and it adds a real scoping constraint: only webhooks created by this API client can be deleted. It does not, however, explicitly contrast with sibling delete_* tools or the webhook siblings (list/create/update_webhook), so an agent must infer routing from the name alone.

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

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

No when-to-use guidance, no mention of when not to delete, and no named alternatives such as update_webhook for modifying an existing webhook. The implied usage (remove a webhook you own) is left entirely to inference.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered. The description adds that tiers and the creator are conditionally returned, which is useful context, but discloses nothing about return shape or edge cases beyond that.

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

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

A single, front-loaded sentence with no filler. It is efficient, though it is arguably slightly thin rather than maximally informative for a 3-parameter getter.

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

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

With an output schema present and 100% parameter coverage, the description needn't explain return values. As a read-only getter the description is nearly complete, only missing the sibling-routing that would fully guide selection.

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

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

Schema coverage is 100%, so the schema already documents campaign_id, include_tiers, and include_creator. The description's mention of tiers and creator mirrors those flags but adds no format or default detail (e.g., that tiers/creator default to true).

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 one campaign') and scope (single campaign) plus included data (tiers, creator). The word 'one' implicitly distinguishes it from the list_campaigns sibling, though it never names that alternative.

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

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

No when-to-use or when-not-to-use guidance. It does not tell the agent to prefer list_campaigns for multiple results or explain the token-scoping condition (which lives only in the schema's campaign_id description).

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds only the scope clarification that this returns the token's own creator; it says nothing about auth failure modes, rate limits, or what the payload contains beyond what the output schema already provides.

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

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

A single front-loaded sentence with zero filler that answers what the tool returns and whose identity it is.

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

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

With an output schema present, return values need not be described, and the annotations carry the safety profile. The definition is near-complete for a zero-required-param read tool; only explicit sibling routing 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% and both parameters (include_email with its identity[email] scope note, include_campaign) are fully documented in the schema. The description adds no parameter meaning, 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 the authenticated Patreon user') and adds scope clarification ('the creator behind the token'). This implicitly separates it from get_member/get_campaign siblings, which fetch arbitrary records, though it never names them 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?

Usage is implied by the self-referential framing ('authenticated', 'behind the token'), but the description offers no explicit when-to-use or when-not-to-use guidance and never mentions the sibling alternatives (get_member, get_campaign).

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

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

Annotations already declare readOnly, idempotent, and non-destructive, so the safety profile is covered. The description adds genuine behavioral context beyond that: the stream key is redacted by default, which tells the agent exactly what it will and won't receive. It stops short of richer detail like auth or rate-limit behavior.

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

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

Two short sentences with zero waste. The core action is front-loaded and the redaction caveat follows immediately where it is most useful.

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

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

With an output schema present, return values need not be described, and annotations carry the safety profile, so the description only needs to add behavioral quirks — which it does via the stream-key redaction note. It is nearly complete, missing only mention of any auth or access requirements implied by openWorldHint.

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 (live_id and include_stream_key) are already documented, with include_stream_key explicitly flagged as a streaming credential. The description restates the redaction/default behavior but adds no syntax or format 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 (Get) and resource (a livestream), and scopes the return to 'state and RTMP connection details'. The get/update/create distinction from siblings like update_live and create_live is implicit in the verb, 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?

Usage is only implied by the tool's nature (fetching a livestream's current state). There is no explicit when-to-use, when-not-to-use, or reference to alternatives such as list_live or update_live, so the agent must infer the context.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds a genuinely useful behavioral detail beyond the schema: content is truncated at 100,000 characters, which warns the agent that the payload may be incomplete.

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

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

A single tight sentence with the cap constraint placed where it will be read. The phrase 'via the web API' is mildly redundant filler that doesn't help an agent decide or invoke, but overall the description is 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?

An output schema exists, so return values need no explanation, and the truncation cap is disclosed. However, for a tool with several near-identical read siblings, the description omits the one thing the agent needs most: what 'managed' distinguishes it from get_post.

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% for the single post_id parameter, so the schema carries the semantics. The description adds nothing about the identifier format or behavior, 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?

The description gives a clear verb+resource ('Get a post/draft'), but it never explains what 'managed' means or how this differs from the sibling get_post. With get_post, list_posts, and list_drafts all present, an agent cannot confidently choose between them from the text alone.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as get_post. The word 'draft' hints at scope but is not framed as a selection condition, leaving the agent to infer 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false. The description adds no behavioral context beyond that—it does not mention PII/scope requirements, optional includes, or return behavior. With annotations covering safety, the bar is lower, but the description still contributes almost nothing new.

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

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

A single front-loaded sentence with no wasted words. It states the core action and identifier immediately.

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

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

Given that a full output schema exists and the input schema documents all six parameters with scope/PII details, the description is nearly complete. It omits the optional include behavior entirely, but that is covered by the schema, so it is largely sufficient for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description repeats the member UUID requirement already documented in the schema and adds no additional meaning for the five optional include parameters.

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

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

The description states a specific verb and resource ('Get one patron') plus the required identifier ('by member UUID'). It clearly distinguishes this singular retrieval from the sibling list_members, so an agent can route correctly without opening the schema.

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

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

The description provides no explicit when-to-use guidance, prerequisites, or named alternatives. It implies usage when a member UUID is known, but does not tell the agent when to prefer this over list_members or get_identity.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is fully covered. The description supplements this with the useful fact that the response includes full HTML content, but says nothing about authentication, post visibility, or 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?

A single front-loaded sentence with no filler; the return-content detail is packed into the same clause rather than 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?

An output schema exists, so return-value explanation is unnecessary, and the lone parameter is fully documented. The only real gap is the absence of routing guidance versus the similar get_managed_post and list_posts siblings.

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

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

Schema description coverage is 100% and the single post_id parameter is documented as a 'Patreon post ID.' The description adds no format, source, or sourcing guidance 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 (Get) and resource (post) and adds the notable detail that full HTML content is returned. However, it never distinguishes itself from siblings such as get_managed_post or list_posts, leaving the agent to guess which retrieval tool applies.

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

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

There is no indication of when to use this versus list_posts (bulk listing) or get_managed_post (managed-post variant), and no mention of prerequisites such as needing the post ID from a listing call. Usage must be inferred entirely from the tool name.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is fully covered by structured data. The description contributes one useful behavioral fact — the result set is implicitly scoped to the authenticated creator — but says nothing about pagination, result caps, or ordering, which matters for a list endpoint.

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

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

A single sentence with zero filler, and the most important constraint (ownership scope) is front-loaded rather than buried. Nothing in it is redundant with 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?

An output schema exists, so return-value shape need not be described, and the annotations carry the full safety profile. The only real gap is collection behavior (pagination/ordering), which is minor for a simple read-only list tool.

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

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

Schema description coverage is 100%, so both optional booleans (include_tiers, include_creator) are already documented with defaults in the schema. The description adds no meaning 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 (List) and resource (campaigns) plus a scoping qualifier ('owned by the authenticated creator'), which separates it from get_campaign and from the post/webhook/member listing siblings. It does not, however, explicitly name any sibling as the alternative for a different scope, so it stops short of full 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?

There is no when-to-use guidance: no statement that this returns the full collection versus get_campaign for a single campaign, no mention of when to toggle include_tiers/include_creator, and no exclusions. The agent must infer usage from the name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds only that this routes 'through the web editor API,' implying a web-session context, which is mildly useful but thin. No further behavioral detail (ordering, volume, freshness) is disclosed.

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

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

A single tight sentence with the resource and scope front-loaded and zero filler. It is efficient, though it may be slightly under-specified rather than optimally concise.

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

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

An output schema exists, so return shape need not be explained, and annotations cover the safety profile. Still, for a paginated list tool the description says nothing about result ordering, whether empty results are possible, or how drafts differ from list_posts, leaving the minimum viable level.

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 3 parameters, including the cursor/page_size pagination contract and the campaign_id fallback to the web session. 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 specific verb ('List') and resource ('unpublished drafts for a campaign'), which is more precise than a generic list. However, it never distinguishes itself from the closely related sibling list_posts, leaving the agent to infer that drafts are a distinct, unpublished subset. Clear but lacks 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 no when-to-use guidance, no prerequisites, and does not name an alternative such as list_posts for published content. The phrase 'through the web editor API' hints at a context but does not tell the agent when this tool is the correct choice over its many list/get siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety and idempotency profile is covered. The description usefully adds that pagination is cursor-based, but says nothing about default page size behavior, ordering, or rate limits beyond what the schema provides.

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 ten-word sentence with zero filler, front-loading the resource and the pagination model. Nothing redundant or 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?

With a rich 8-parameter schema at 100% coverage and an output schema present, the description needn't explain returns or filters. The one thing worth flagging at this level — pagination — is stated. It is complete enough for correct invocation, though it could note ordering or the PII-sensitive nature of some includes.

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 including cursor, page_size, and the include_* PII flags is fully documented in the schema. The description only echoes the cursor-pagination concept, adding no meaning beyond the structured fields. Baseline 3 applies.

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

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

States a specific verb ('List') and resource ('patrons for a campaign'), and adds the pagination model ('cursor pagination'). It does not name or distinguish itself from siblings like get_member or list_campaigns, so an agent must infer the distinction from the plural resource alone.

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

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

No when-to-use guidance is given in the description. It never states when to reach for this instead of get_member (single patron) or list_campaigns, nor any prerequisites; the only conditional guidance lives in the schema's campaign_id description, not here.

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, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is well covered. The description adds only the cursor-pagination trait, which is already documented in the schema, and gives no extra context on auth, rate limits, or scoping behavior.

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

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

The description is a single, front-loaded sentence with zero wasted words. It states the action, scope, and pagination model efficiently.

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

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

Rich annotations, a full-coverage input schema, and an output schema mean the description need not explain safety or return values. However, it leaves a real gap by not distinguishing list_posts from sibling list_drafts or get_post, and provides no usage guidance.

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

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

Schema description coverage is 100%, so all four parameters are fully documented in the input schema. The description adds no parameter meaning beyond what the schema already provides, making the baseline 3 appropriate.

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

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

The description states a specific verb and resource: 'List posts', with scope 'for a campaign' and behavior 'cursor pagination'. It is clearly distinguishable from get_post, but it does not explicitly differentiate itself from sibling list_drafts or explain what kind of posts are returned.

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

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

The description gives no when-to-use guidance, no conditions, and no alternatives. It implies scoping to a campaign but does not tell the agent when to prefer list_posts over get_post or list_drafts.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, idempotentHint=true), so the bar is lower. The description still adds real behavioral context beyond them: signing secrets are redacted by default, telling the agent what it will and won't see in the result.

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

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

Two short sentences, zero filler, with the core action front-loaded and the redaction caveat immediately after. Every clause earns its place.

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

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

For a read-only list tool, annotations cover safety, an output schema exists so return shape need not be described, and the schema fully documents the single parameter. The description adds the one non-obvious trait (default redaction); only pagination/scope limits are unaddressed.

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

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

Schema description coverage is 100%, so the include_secrets parameter and its default are already fully documented in the schema, including the reason ('account credentials'). The description's 'redacted by default' restates that default rather than adding new syntax or semantics, 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?

States a specific verb ('List') and resource ('webhooks') and scopes it to 'this API client's webhooks', which cleanly distinguishes it from the create_webhook/update_webhook/delete_webhook siblings by the enumeration verb.

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

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

The description implies usage (enumerate existing webhooks) but never states when to reach for this tool versus get/update/delete_webhook, nor any prerequisites. The redaction default hints at the safe-read use case but no explicit when/when-not guidance is given.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true and destructiveHint=true, so the safety profile is largely covered by structured data. The description adds that the target must already exist as a draft and that the operation goes through the web editor API, but it never explains what the 'destructive' flag means here (whether the draft record is consumed or replaced) or what the success response confirms. Given annotation coverage, this is adequate but thin.

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

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

One sentence, no redundancy, with the outcome ('publish') front-loaded and the scope ('existing draft') immediately after. Nothing to trim.

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 mutation with full schema coverage, rich annotations, and an output schema that handles return values, the description only needs to state the action and precondition — which it does. The remaining gap is the unexplained destructiveHint and any failure modes (publishing a non-draft, already-published posts), which is a minor omission given complexity.

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

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

There is a single parameter, post_id, with 100% schema description coverage, so the schema fully documents it. The description adds no format, sourcing, or lookup guidance (e.g. where to get a valid post ID) 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?

The description gives a specific verb ('Publish') plus a specific resource ('an existing draft') and the mechanism ('Patreon's web editor API'). The 'existing draft' qualifier implicitly distinguishes it from create_post/update_post, though it never names a sibling or states the boundary explicitly.

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

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

There is no when-to-use guidance, no prerequisites (e.g. the post must already exist as a draft, the caller's tier/permission needs), and no reference to alternatives such as update_post or create_post. The only hint is the phrase 'existing draft', which is inference rather than instruction.

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 destructiveHint=true, idempotentHint=true and readOnlyHint=false, so the safety profile is covered. The description adds one genuinely useful behavioral fact not in the annotations or schema: the stream key is redacted by default (privacy/response handling). It omits the operationally important irreversibility of ending a stream, which only appears in the state parameter's schema text.

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 core action front-loaded, with the redaction caveat immediately after. Nothing is wasted or 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?

An output schema exists, so return values need no explanation, and annotations carry the mutation profile. However, for a state-machine mutation that can permanently end a livestream, the description should at least signal the irreversibility and the sibling boundaries that now live only in the schema and sibling 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% and the state parameter already documents the pre_live -> live -> live_ended lifecycle with the no-transitions-after-ended rule. The description's note that the stream key is redacted by default lightly reinforces include_stream_key, but adds no syntax or format meaning 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 clear action (start or end a livestream) on a specific resource, which distinguishes it from create_live and get_live. It never uses the word 'update' or names the state-transition framing explicitly, so an agent must infer that this is the state-change tool, but the intent is still legible.

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

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

No when-to-use guidance and no routing to alternatives. It does not say to use create_live to set up a stream or get_live to inspect one, nor when a caller should pick 'live' vs 'live_ended'.

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 destructiveHint=true, idempotentHint=true and openWorldHint=true. The description adds real behavioral context beyond that: an authentication prerequisite (web session) and the important default that omitting publish leaves publication state unchanged. It stops short of explaining what the destructive aspect actually destroys (e.g., whether unspecified fields are cleared).

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

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

Three short sentences, front-loaded with purpose before the conditional publish logic, with no filler. Minor redundancy with the schema's publish wording keeps it out of 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?

An output schema exists, so return values need not be described, and the publish/schedule flow is covered. However, for a destructive, 11-parameter mutation tool, the description never clarifies whether omitted fields are preserved or cleared, which is exactly the ambiguity an agent needs resolved before calling it.

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

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

Schema description coverage is 100%, so the schema already documents all 11 parameters thoroughly. The description's publish explanation ('publish=true to publish now, or publish=true plus scheduled_for to schedule') largely restates the schema's own publish description, adding little new meaning; baseline 3 is appropriate.

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

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

The description gives a specific verb+resource ('Update or publish an existing post') plus the underlying API surface ('Patreon's web editor API'), which is enough to distinguish it from create_post and delete_post. It does not, however, address the overlap with the sibling publish_post tool, so sibling differentiation is incomplete.

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

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

It states a prerequisite ('Requires a web session') and gives conditional semantics for the publish flag, which is useful. But it never says when to prefer this tool over publish_post or create_post, nor any when-not-to-use condition, leaving tool selection largely to inference.

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

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

Annotations declare destructiveHint=true and idempotentHint=true, but the description adds real context the annotations don't: an external configuration dependency (PATREON_WEBHOOK_ALLOWED_HOSTS) gating URI changes, and the side effect that unpausing redelivers queued patron events. It stops short of stating irreversibility or how partial updates behave.

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 tightly written sentences, front-loaded with the operation scope, then the two non-obvious caveats. No filler or repetition.

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

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

With an output schema present, return values need no explanation, and the description covers the operation scope plus the two behavioral gotchas that matter most (host allowlist, event redelivery). Only minor gaps remain around partial-update semantics and reversibility of a URI 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 description coverage is 100%, so every parameter is already documented in the schema (including the paused redeliver semantics). The description only restates the parameter names, adding no syntax, format, or constraint detail beyond the schema baseline.

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

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

States a specific verb (update) and resource (webhook) plus the exact mutable fields (URI, triggers, paused state). Combined with the sibling list (create_webhook, delete_webhook, list_webhooks), an agent can immediately tell this is the mutation path for an existing webhook.

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 'update' verb against the create/delete/list siblings, and the host-allowlist prerequisite for URI changes is a useful precondition. However, it never explicitly says when to choose this over alternatives (e.g. delete + recreate) or that at least one field should change.

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