gardenpatch

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

With no annotations, the description carries the full burden and does so well: it flags paid cost, real-world irreversible side effect on a real person, the consent requirement, the absence of a sandbox, and exact idempotency-key retry semantics. It discloses not just what happens but the consequences for the agent's decision-making.

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 critical warning ('HAS A REAL-WORLD SIDE EFFECT') is front-loaded, and every following sentence — consent, sandbox, idempotency — adds a distinct fact an agent needs. No filler.

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

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

Given the absence of annotations and output schema plus a nested body requiring get_schema, the description covers the safety and retry behavior thoroughly. The one minor gap is that it doesn't say what comes back (e.g., a receipt), which would help an agent chain to get_receipt.

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 slug, body, and idempotency_key. The description repeats the idempotency-key semantics almost verbatim from the schema and reiterates the consent block, adding little new meaning beyond the 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?

It states the concrete effect — 'it puts a message in front of an actual person' — which is more specific than the generic name 'call_action'. However, it never names the operation as 'sends a message via the selected action slug', and it doesn't differentiate itself from siblings like sandbox_call or get_receipt by name.

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 sandbox for this — a simulated send cannot be told apart from a real one' is a clear usage exclusion and implicitly steers the agent away from sandbox_call, while the idempotency note tells it how to handle retries. The alternative tool isn't explicitly named, so it's clear context rather than full when/when-not/alternatives 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?

With no annotations, the description carries the full burden and does substantial work: it discloses the price floor ($0.18/call), the settlement rail (USDC on Base via x402), and the exact failure mode for an unpaid call (structured payment requirements plus retry), which is the single most important behavior for an agent to anticipate. It stops short of latency, rate limits, or whether a retry without an idempotency key could double-charge.

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?

Four tight sentences with no filler, and the retry and sandbox guidance land early. The one structural weakness is that it opens on price and settlement rather than on what the tool does, pushing the actual capability explanation to the second sentence.

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 tool with a nested context object, no annotations, and no output schema, the description supplies both the shape of a successful return and the shape of the unpaid error, which is the pair of outcomes an agent must handle. It leaves 'typed deliverable' undefined and says nothing about whether context values are echoed back or how long a synthesis takes.

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 mode enum, agent enum, context blob, messages array, and idempotency_key are all already documented in the schema, including the sharp warning that an unsupported mode is a 400 rather than a fallback. The prose adds nothing parameter-specific, so the baseline of 3 applies.

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

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

The description states concretely what a call produces (growth diagnosis, the arithmetic behind it, concrete actions, a typed deliverable) and how it is billed, which is a specific verb-and-resource picture rather than a restatement of the name. It differentiates itself from one sibling by naming sandbox_call, but never positions itself against call_tool or call_action, so an agent must infer that this is the coach-specific variant.

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

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

It gives explicit routing advice: use sandbox_call if you only need to see the shape, and expect a structured payment-requirements error that you can settle and retry without payment. What's missing is any guidance on choosing among the coach/payment siblings (call_tool, call_action, list_coaches) or when a paid call is warranted over a free one.

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

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

With no annotations, the description carries the full burden and does real work: it discloses the pricing floor ($0.01), the settlement rail (USDC on Base via x402), the no-charge-on-refusal rule, and a privacy claim that tools contact no one and store nothing. It stops short of explaining payment failure handling, retry/idempotency behavior, or whether errors other than input refusal are billed.

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?

Four compact sentences that front-load the cost and payment mechanism before the behavioral guarantees. Dense and nearly waste-free, though the privacy clause about URLs sits slightly awkwardly in an otherwise generic execution description.

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 tool with a free-form nested body object, six enum slugs, no output schema, and no annotations, the description covers the commercial and trust model well and correctly defers per-tool request shape to list_tools/get_schema via the schema itself. The missing piece is the return shape and any payment handshake detail.

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

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

Schema coverage is 100% and both parameters describe themselves, so baseline is 3. The description adds only indirect meaning to body by noting that site-signals and image-resize read just the one public URL provided, which hints at body contents for two of six slugs but does not characterize slug or body generally.

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?

"Runs one utility and returns its result" gives a specific verb and a bounded scope, and the paid/x402 framing separates it from free-looking siblings like sandbox_call. It doesn't name the sibling tools it competes with (call_action, call_coach, sandbox_call), so the differentiation is implied 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 makes clear this is a paid execution path and notes that input-refused requests are free, which is useful routing context. However, it never says when to prefer sandbox_call over this, when to use get_schema or list_tools first, or when to pick a sibling like call_action instead.

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

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

With no annotations, the description carries the full burden and does well: it discloses cost (free), an authorization constraint (only the paying wallet), and a lifecycle constraint (expiry). It does not cover failure behavior when the wallet is wrong or the receipt has expired, but the key traits an agent needs are present.

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

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

Two sentences, front-loaded with the 'Free' cost signal and then the payload and constraints. Every clause earns its place with no repetition of the name or 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 simple two-parameter read with no output schema, the description enumerates the returned fields and covers access and expiry constraints. Only edge-case behavior (expired receipt, mismatched wallet) is left unstated.

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

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

Schema coverage is 100%, so both parameters are already documented, establishing a baseline of 3. The description's 'only the wallet that paid can read it' adds authorization rationale for payer_address, but adds no format or syntax detail beyond the schema.

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

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

States a specific verb and resource: 'Returns a call you already paid for' with enumerated contents (amount, mode, usage, deliverable). It distinguishes itself implicitly from the call/pay siblings by scoping to already-paid receipts, though it never names an alternative tool.

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 precondition ('a call you already paid for') and the 'Free' cost signal imply when to use this instead of paying again, but no sibling is named and there is no explicit when-not guidance (e.g., what to use for a first-time purchase or a different receipt).

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the tool is free and returns published schemas, but it does not mention authentication requirements, rate limits, error behavior, or other operational details.

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

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

The description is short, front-loaded with the key 'Free' detail, and every sentence contributes useful information about cost, output, and intended use. There is no redundant or filler content.

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

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

For a simple three-parameter retrieval tool with full schema coverage, the description adequately explains what is returned and why to use it. It is slightly incomplete in not mentioning the tool-slug kind supported by the schema, but the schema itself makes that clear.

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 three parameters and their enums. The description adds little parameter-level detail beyond restating that the result is for a mode or action, and it omits the tool-kind option covered by 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 clearly states that the tool returns a published request or response JSON Schema for one mode or one action. It is specific about the resource and output, but it does not explicitly distinguish itself from siblings such as sandbox_call or list_actions.

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

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

The description gives a clear usage context: use it to build a request that will validate before paying for a call. It does not explicitly state when not to use it or contrast it with alternatives like sandbox_call, but the intended usage is clear.

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

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

No annotations, so the description carries the full behavioral burden, yet it describes the nature of the listed items (paid side effects, consent rules) rather than the tool's own operation. It never says listing is a safe read-only operation, what it returns, or whether it paginates. Domain context is useful, but operation-level transparency is largely absent.

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?

Short and front-loaded with the 'Free' cost signal, but the opening fragment is cryptic and two of the three sentences explain the concept of an action rather than what this call does. Some text doesn't earn its place relative to the tool's job.

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 annotations and no output schema, the description must supply the behavioral picture, and it only partially does: it explains the domain (paid, consent-gated actions) but not the return shape or read-only nature of the listing. Enough to understand the concept, not enough to predict the call's behavior.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing for the description to clarify about inputs, and it correctly doesn't invent any.

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 conveys that this is a catalog/listing of available actions and defines what an action is ('does something rather than returning advice'). It doesn't explicitly use a listing verb or contrast with the obvious sibling call_action, which would invoke one of these entries. Purpose is clear but sibling differentiation is left implicit.

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

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

The word 'Free' and the framing as a catalog imply 'browse here before invoking something paid,' but neither the when-to-use nor the alternative (call_action vs. list_tools) is stated. Usage must be inferred.

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

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

With no annotations, the description carries the full burden and does well: it discloses cost ('Free'), freshness guarantees ('generated from the same registry the paid endpoint validates against, so it is never stale'), and the shape of what comes back. It doesn't state read-only semantics explicitly, but 'catalog' and 'Free' strongly imply it.

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 cost signal and the 'call this first' directive, then the trust signal. No filler.

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

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

For a zero-param, output-schema-less list tool, the description covers what makes a caller act: what's returned, that it costs nothing, that it's authoritative and fresh, and that it should be called before the paid tools. Nothing an agent needs 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?

Zero parameters, so there is nothing to disambiguate; baseline 4 applies. The description correctly spends no words on inputs.

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

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

States a specific resource and its exact contents: 7 growth coaches, the 16 modes they sell, and each mode's price. The word 'catalog' plus the concrete counts makes it unmistakable next to siblings like call_coach or list_actions.

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?

'Call this first' gives explicit ordering guidance, and 'Free' versus 'the paid endpoint' frames the cost tradeoff against call_coach. It stops short of naming the sibling tools or stating when not to call it, so it lands just under a 5.

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

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

With no annotations at all, the description carries the full burden and does reasonably well: it discloses that the call costs nothing, that the response is a fixed catalog of six items, and what fields come back (price, request schema, worked example), which substitutes for the absent output schema. Auth or rate-limit behavior is still unmentioned.

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?

'Free.' is front-loaded as the single most decision-relevant fact, the parenthetical enumerates the six utilities compactly, and the trailing 'One endpoint, one job, one payment' is short enough to pass as a positioning cue 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?

For a parameterless, annotation-free catalog tool with no output schema, the description supplies what an agent needs: cost, item count, item categories, and the shape of each entry. It could be stronger by stating the intended next step (pick a utility, then call_tool/get_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?

The tool takes zero parameters, so the baseline is 4; there is nothing for the description to disambiguate and it correctly presents the call as argument-free.

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

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

Names the resource (a catalog of 6 utilities) and enumerates exactly what each entry contains: price, request schema, worked example. That is specific enough to separate it from siblings like list_actions or list_coaches, though it never explicitly contrasts itself with 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?

'Free' and 'One endpoint, one job, one payment' imply this is the discovery step before paying for a utility, but the description never says when to call it versus get_schema, list_actions, or call_tool. The workflow role is inferable rather than stated.

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

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

With no annotations, the description carries the burden and does well: it discloses that the call is free, requires no wallet/payment, returns a fixed sample rather than computing on input, and mirrors the paid-call envelope. It omits whether the sandbox counts against quotas or is rate-limited, which would complete the picture.

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

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

Front-loaded with the key fact ('Free, and no wallet needed') and four short sentences that each carry information. Slight redundancy in 'that is what makes it free', which restates the fixed-sample idea rather than adding a new constraint.

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

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

For a two-required-enum-param tool with no output schema, the description supplies the critical missing piece: what a return value looks like (same envelope/field names/deliverable shape as a paid call). What's left unexplained is the relationship between the 16 modes and the sample returned, 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% and both params are enums with descriptions, so the schema already documents mode and agent fully. The description only re-touches 'for a mode' and says nothing about how the coach (agent) choice affects the sample, so it adds 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?

States a specific verb and resource: it returns a schema-valid sample response for a given mode/coach, with the same envelope and field names as a paid call. The contrast with a real 'paid call' implicitly separates it from call_coach/call_action/call_tool, so an agent can tell it apart without opening siblings' schemas.

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

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

Explicitly directs the agent to use it before a real call ('Build your integration against this first') and clarifies that it is not an answer to input, implying the paid siblings are for actual work. It stops short of naming the alternatives explicitly or stating hard exclusions (e.g., don't use for production data).

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