Good Earth

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

With no annotations provided, the description carries the burden of behavioral disclosure. It discloses that the tool is 'Free — no credits consumed', which is crucial cost information, and that proof of npub ownership is required to prevent statement-scraping, adding a security context. It also details the dpop_token format requirements, which is behavioral. However, it does not mention the output structure or any side effects, but given the output schema exists and the description covers core behavior, this is above average.

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 concise, direct, and front-loaded with the main purpose. Each sentence adds value: returns content, clarifies the account type, and highlights key constraints (free, proof required). No fluff or repetition of schema details. Well-structured for quick parsing.

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

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

The description is complete for the tool's purpose: it clarifies what the statement contains, what it is not (authority balance), cost, and authentication prerequisites. The output schema presumably covers the return structure, so that is not a gap. Minor omission: no mention of pagination or limits, but given complexity and output schema, this is sufficient.

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

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

The schema has 100% description coverage, so the schema already documents npub, dpop_token, and days. The description adds context about dpop_token's requirements (raw JSON, kind-27235, 'u' tag with tool's name) which goes beyond the schema's description, but it does not add much for npub or days beyond what's in the schema. Since coverage is high, a 3 is a fair baseline, with slight credit for enriching dpop_token semantics.

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 a specific verb ('Generate'), a specific resource ('patron's account statement'), and the scope ('at this operator'). It lists the contents (purchase history, credit tranches, usage breakdown, daily logs) and distinguishes itself from the operator's Authority tax balance, which helps set it apart from siblings like goodearth_check_balance and goodearth_check_authority_balance. This is a clear, specific purpose.

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

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

The description implies usage context: it is for accessing a patron's spending account, not the operator's tax balanceikuha. It also states the requirement of npub ownership proof via dpop_token, which guides the agent on prerequisites. However, it does not explicitly state when NOT to use this tool or compare to specific alternatives; the sibling list includes many other tools, but the description only contrasts with the authority balance, missing explicit 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?

With no annotations provided, the description carries the behavioral disclosure burden. It adds meaningful context: the call costs 1 api_sat, proof is verified by debit_or_deny before cost is incurred, and the output is a dark-themed SVG with specific visual sections. It does not mention rate limits or state mutations, but the disclosed cost and verification behavior are genuinely useful beyond the schema.

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

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

The description is compact: three sentences, primary purpose first, then output contents, then cost and verification. Every sentence adds distinct information with no repetition or 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 tool with a rich output schema, fully documented parameters, and one highly relevant sibling, this description is complete enough. It covers what the tool produces, how it relates to account_statement, what it costs, and the verification mechanism, leaving no critical gap for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already documents npub, dpop_token, and days thoroughly. The description adds no extra meaning about parameter formats or usage beyond what the schema provides, so no bonus is warranted.

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 opens with a specific verb and resource: 'Generate a visual SVG infographic of your account statement.' It explicitly distinguishes itself from the sibling goodearth_account_statement by stating it returns the same data but rendered as a dark-themed SVG graphic, making the tool's unique role clear.

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 clarifies the tool is the visual counterpart to account_statement, which tells an agent when to prefer it: when an infographic is needed rather than raw statement data. It does not explicitly list exclusion conditions or alternative tools beyond this one comparison, so it falls just short of full 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?

No annotations are present, so the description carries the full burden. It does disclose a non-mutating polling action ('Polls the Authority MCP-to-MCP'), a cost trait ('Free'), and the statuses returned. However, it does not mention auth requirements, errors, or whether a prior adoption request is required, though the read-only nature is reasonably clear.

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 definition is short and front-loaded: the purpose sentence comes first, followed by the cost and mechanism detail. Every sentence earns its place, and there is no redundant or vague filler.

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

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

An output schema exists, so return-value documentation is not the description's job. However, for a tool with two parameters and no annotations, the description still omits relevant context: when an adoption request must already exist, how the Authority is chosen, and what dpop_token does. It is adequate for a simple status poll but not fully complete.

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

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

Schema description coverage is 0%, and the description barely compensates. 'Chosen Authority' maps to authority_npub, but the format and meaning of that parameter are not explained, and dpop_token is never mentioned. The agent gets little beyond the bare parameter names and the default value from 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 opens with a specific verb and resource: 'Check this operator's adoption-request status at a chosen Authority.' This is unique among siblings and not easily confused with goodearth_request_adoption or goodearth_check_proof_status. It also lists the possible statuses, clarifying what the tool returns.

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 explicit when-to-use guidance, prerequisites, or alternatives. An agent can infer that checking status is the purpose, but nothing says when to call this instead of goodearth_request_adoption or other status/check tools. No exclusions or fallback routing are provided.

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 are provided, so the description carries the disclosure burden. It explicitly lists the data dimensions and the normal/actual/forecast comparison, notes that sun and moon are computed exactly rather than forecast, and reveals an aggregation cost: 'three upstream requests regardless.' It does not explicitly state read-only behavior, but the 'record' framing and absence of mutation language make that apparent.

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 three short paragraphs that front-load the normal/actual/forecast framing before listing the data and usage context. Every sentence contributes scope, data, or usage guidance, though the opening is poetic rather than purely operational. It is concise enough for an agent to parse quickly.

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 is present, so explaining return values is not required. The description covers the data dimensions, time horizons, aggregation behavior, and usage rationale, while the schema handles block identification and billing prerequisites. It could name sibling alternatives more explicitly, but 'One call covers every measure' partially compensates.

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 schema already describes block and npub in detail, and the description adds no parameter-specific guidance beyond reinforcing the block-as-ground concept. It does not explain dpop_token or add constraints beyond what the schema provides. With 67% schema description coverage, the description's lack of parameter detail is acceptable but not additive.

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 identifies the resource (a block/ground) and the delivered data: temperature, dew point, rain, wind, sunshine, day length, sun, and moon, each against normal, actual, and fortnight-ahead values. It differentiates itself from the many specialized siblings by emphasizing 'One call covers every measure.' It is slightly indirect because it relies on 'says' and 'record' rather than a direct verb like 'retrieves' or 'returns.'

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 positions the tool as the complement to heat/degree-day data: 'Growers read these together with the heat,' and it explains when high dew points or a dry August make degree-day totals insufficient. It also implies broad use instead of multiple specialized calls with 'One call covers every measure.' It does not name specific sibling tools or explicit exclusions, but the usage context 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?

With no annotations, the description carries the disclosure burden. It adds useful non-obvious behavior: as_of returns historical state, and sort/search execute over all block rows, not the displayed page. It does not state read-only safety, authentication/billing requirements, or rate limits, which would be material in the absence of annotations.

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

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

Three short sentences with no filler, and each sentence contributes a distinct point: list scope, historical semantics, and database-wide search/sort behavior. It loses one point because the opening sentence is oblique rather than a direct statement of the operation.

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

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

The detailed schema and output schema carry most of the load, and the description covers the two non-obvious runtime behaviors. However, with no annotations, authentication/billing via npub and the read-only safety profile are left implicit rather than stated in the description.

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 93%, so the baseline is 3; the description adds value beyond the schema by explaining as_of's historical semantics and by disclosing that sort/search operate across the whole block. It does not add parameter syntax, but the extra behavioral nuance is genuinely helpful.

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 title and description together identify the resource: a page of records for things grown, watched for, or seen on a plot, which maps to the planting/pest/wildlife/observation kinds in the schema. It lacks an explicit 'Lists...' verb, but the intent is recoverable and distinguishable from sibling block_list and block_item_save tools.

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 when to use the tool: fetching block-item records, including historical state via as_of, and clarifies that sorting/searching span the block's full data rather than the page. It never names alternatives or gives when-not-to-use guidance, leaving an agent to infer selection from the sibling names.

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 provided, the description must carry the full behavioral burden. It says 'Record' and mentions 'fare,' hinting at billing, but it does not disclose that the operation persists writes, requires an npub for credit billing, supports amendment via item_id, or that retire_ids only retires items without deleting them. These side effects are left to the schema.

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

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

The description is two short sentences with the action front-loaded and the rationale second. It avoids restating parameter names or schema content, and the 'afternoon in the field' rationale earns its place by explaining the batch-call design.

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

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

The tool has 7 parameters, no annotations, and an output schema signal, so the description alone is not fully self-sufficient. The schema fills in most parameter-level details, but the definition still lacks explicit behavioral framing for a mutating, billing-related write tool. It is adequate if the agent reads the schema carefully, but not complete on its own.

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 86%, so most parameters are already documented. The description's 'what you grow, watch for, or saw' adds a light conceptual mapping to the kind values, but it does not clarify item shapes, the npub requirement, season defaults, or retire semantics beyond what the schema provides. This matches the baseline for high schema coverage.

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

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

The opening clause 'Record what you grow, watch for, or saw on a plot' is a specific verb-plus-resource statement and maps well to the tool's planting/pest/wildlife/observation item kinds. The batch framing makes the write intent clear, though it does not explicitly distinguish itself from siblings such as goodearth_block_item_list or goodearth_block_save.

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 second sentence gives a clear context: use one call for many field notes rather than a separate fare per note. However, it does not explicitly name alternatives or state when not to use the tool, so the usage guidance is implied rather than fully articulated.

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 of behavioral disclosure. It reveals notable traits: the response size stays constant regardless of plot count, empty results include a marked worked example, overlapping blocks are treated as multiple separate blocks, and overlaps should be read as intent. It does not mention auth or billing behavior, but the schema covers npub and the operation is a list/read.

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 compact at roughly 70 words and each sentence adds behavioral or scoping information: scope, item exclusion, empty behavior, and overlap semantics. The style is somewhat poetic and lacks a front-loaded verb phrase, but the structure is logical and avoids waste.

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 output schema exists and the sibling set includes related block/item tools, the description covers the key contextual cases: empty results, overlap semantics, and scope boundary. It is sufficient for an agent to select this tool and understand its unusual behaviors, though it leaves the undocumented dpop_token parameter to be inferred from convention.

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 description adds no parameter-level meaning beyond the schema. Schema description coverage is 67%, with npub and include_retired documented in the schema, but dpop_token remains undescribed. Since the tool description itself never mentions include_retired, npub, or dpop_token, it does not compensate for the undocumented parameter or add value beyond the input 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 identifies the resource ('the ground you have saved') and scope ('with its bounds'), and explicitly narrows the result to 'the blocks themselves and nothing else,' which separates it from block_item_list. It lacks a direct verb like 'list' and relies on the tool name for the action, but the resource and boundary are clear.

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 an implicit routing cue: content like 'what grows on them, what you watch for, and what you have seen are their own listing,' signaling that this tool is only for blocks themselves and another sibling handles items. It also explains the empty-state behavior ('a grower who has saved nothing gets the worked example'), though it does not explicitly name the alternate sibling tool.

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

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

The description usefully discloses that area and sample count are computed from the provided bounds and need not be tracked externally, and that overlapping blocks are valid. With no annotations, it still does not disclose mutation/update side effects, billing requirements, or persistence behavior, leaving part of the safety burden unmet.

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 compact, front-loaded with the core action, and every sentence contributes a distinct point: prerequisite relationship, computed outputs, and overlap validity. The grower example is slightly narrative but directly prevents a common misunderstanding.

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 no annotations and 8 parameters, the description plus a rich input schema covers the essential mental model: create/update via block id, geometry bounds, overlap tolerance, and computed outputs. It could add an explicit mutation warning or billing mention, so it is not a perfect 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 coverage is 88%, so the schema carries most parameter documentation. The description adds real meaning beyond the schema by explaining that geometry drives computed, authoritative outputs (area and sample count) and by reaffirming the geometry param's overlap semantics. It does not elaborate on name/alias/base_temp, but those are already well covered 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?

The opening sentence names a specific verb and resource ('Save a plot of land') and states the upstream purpose ('so every other tool can work it by name'). This clearly differentiates block_save from list/read siblings like goodearth_block_list and goodearth_block_item_save.

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 clear context for when to call the tool: before other tools can reference ground by name. It also explains the allowed overlap/nesting rather than leaving the agent to assume duplicates are errors; no exclusion criteria are given, so it stops one step short of an explicit when-not-to-use statement.

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

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

With no annotations, the description carries the full burden and discloses the important side effects: the dataset is stored, an iCalendar feed is published under a token, recomputation happens in place, and refreshes update events rather than duplicating them. It also explains why refresh is safe by tying the computation to the block record. It does not mention billing or authorization, but the core mutation and idempotency behavior is transparent.

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 core sentence is front-loaded, but the description becomes quite long and includes illustrative material like 'appears next to the school run and the market stall' and a historical rationale for why refresh is safe. These add color and rationale, but the prose is noticeably longer than needed for an agent to decide how to invoke the 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 compute-and-store tool with no annotations, it covers the operation, the structured-row output, the iCalendar feed artifact, and token lifecycle behavior. The input schema covers prerequisites like saving a block first, and an output schema exists, so the main missing piece is explicit routing to sibling calendar tools rather than invocation-critical context.

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

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

Schema description coverage is 80%, so the baseline applies and the schema already documents most parameter meaning. The description adds useful context for token and for what the block conceptually contributes, but it introduces a slightly confusing line: 'Nothing is passed in but the block,' which could be read as conflicting with the schema's real parameters like npub, season, and dpop_token.

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 opening sentence names a specific operation and resource: 'Compute this block's dated season as a dataset, and store it for publishing.' Phrases like 'stored alongside', 'feed token', and 'recompute in place' make it clear this creates or refreshes a dataset rather than fetching or listing one. It does not explicitly name sibling alternatives, so an agent must infer the boundary with calendar_fetch/list/revoke.

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 create-vs-refresh condition: pass an existing token to recompute in place, omit it to create. However, it never explicitly says when to use this tool over the calendar_fetch, calendar_list, or calendar_revoke siblings, so routing guidance is implied 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 transparency burden. It discloses that reads are counted, that the unguessable token is the credential, and that this is a read/serving operation separate from computing. It does not detail error behavior, but the output schema covers return shape.

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

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

Purpose is front-loaded in the opening sentence, and the following paragraphs add necessary security and serving context. At roughly 90 words it is appropriately sized and every sentence contributes; slight verbosity in the MCP/JSON-RPC/npub enumeration keeps it from 5.

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

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

For a one-parameter read tool with an output schema, the description explains what it reads, why it exists, how the token authenticates, and that reads are metered. The only minor gap is no explicit mention of when to prefer sibling calendar tools, but the serving context covers that.

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 schema already documents 'token' at 100% coverage, so the baseline is 3. The description adds meaningful semantics by explaining the token is an unguessable credential because iCalendar subscriptions cannot carry a proof, which goes beyond the schema's one-line description.

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 first sentence states a specific verb ('Read') and resource ('stored calendar dataset') keyed by feed token. This clearly differentiates it from sibling management tools like calendar_list or calendar_revoke by focusing on retrieval for serving.

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 second paragraph gives clear context: this tool exists for the Good Earth site to serve a subscribable URL to calendar clients that cannot speak MCP or handle npub proofs. It does not explicitly name sibling alternatives, but the serving scenario is unambiguous.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It implies a read-only operation but says nothing about authentication requirements, rate limits, side effects, or the nature of the response. The description is too sparse to inform the agent of any operational nuances.

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, concise sentence with no redundancy. It front-loads the core purpose. However, it is so minimal that it sacrifices informative content, though that is more a completeness issue than a conciseness issue.

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 list operation with an output schema present, the description should at least indicate what information is returned (e.g., feed names, polling intervals). It also lacks any mention of authentication or the need for an npub, which is a required parameter. The description is inadequate for an agent to confidently invoke the tool without additional context.

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

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

Schema description coverage is 50%: npub is described in the schema but dpop_token is not. The tool description adds no information about either parameter, failing to clarify the role of dpop_token or how npub should be formatted. It does not compensate for the schema gap.

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 identifies the resource ('calendar feeds you have published') and the action (listing them, implied by 'feeds you have published' plus the context of listing). It also adds the detail about polling frequency, which distinguishes it from siblings like fetch or revoke. However, it does not use an explicit verb like 'list', so it relies on inference.

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

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

No guidance on when to use this tool versus alternatives such as goodearth_calendar_fetch or goodearth_calendar_revoke. It doesn't mention prerequisites (e.g., having published feeds) or scenarios where this is the appropriate choice. The description is purely declarative with no contextual direction.

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?

There are no annotations provided, so the description must carry the full burden of behavioral disclosure. While it clearly says 'Stop publishing' (implying a state change) and 'Free' (implying no cost), it does not reveal whether the operation is reversible, whether it requires authentication beyond the token, or what the effect is on subscribers if the feed is re-published later. It also doesn't describe the response format or whether any side effects occur (e.g., deletion of historical data).

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 extremely concise: only three short sentences, all of which add value. It is front-loaded with the primary action ('Stop publishing a feed'), followed by a consequence and a cost note. There is no verbosity or redundancy, and it is easy for an agent to parse quickly.

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 an output schema exists (though not provided in the input), the description does not need to explain return values. However, for a mutating tool with no annotations, the description is somewhat sparse. It omits any mention of required authentication context (e.g., whether the token must belong to the caller), error conditions, or reversibility. The simplicity of the operation (stop publishing) means it is mostly complete at a high level, but the lack of behavioral detail is a 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?

The schema covers two of three parameters with descriptions (npub and token), giving a schema description coverage of 67%, which is moderately high. The description adds no parameter-specific meaning beyond what the schema provides. The 'token' parameter is described as 'The feed token to stop publishing', which is adequate. 'dpop_token' is left undocumented in the schema and description, but it is optional with a default and may not require elaboration. Overall, the description is neutral and does not add significant value over 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 states 'Stop publishing a feed' with a clear verb and resource, and then clarifies the consequence ('Subscribers stop receiving updates'). It is distinct from the sibling tools such as goodearth_calendar_fetch or goodearth_calendar_list. However, there is minor ambiguity in 'feed' — it is not explicitly tied to 'calendar' — but the tool name makes the context clear.

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 explicit guidance on when to use this tool versus alternatives. It does mention a consequence ('Subscribers stop receiving updates') which helps an agent infer usage, but there is no comparison with siblings like goodearth_calendar_dataset or goodearth_calendar_fetch, and no indication of prerequisites such as having a valid token or being the feed owner.

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 are provided, so the description carries the full burden of behavioral disclosure. It discloses that corrections are returned separately, that 'nothing is applied silently', that corrections appear only after multiple observations agree, that implausible values are set aside rather than averaged, and that the source reports are returned. It does not mention authentication, rate limits, or explicit side effects (beyond billing via npub, which is in the schema), but the provided behavioral notes are meaningful and non-obvious.

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 well-structured and front-loaded: a one-sentence summary, a paragraph of context, a paragraph on return values, and a paragraph on behavioral principles. Each sentence serves a purpose: distinguishing the tool, explaining outputs, and setting expectations about safety and consensus. No wasted or redundant wording.

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 tool's complexity, the presence of an output schema, and the rich input schema, the description covers the essential operational and behavioral aspects an agent needs. It explains the output structure at a high level, the consensus requirement, and the fact that reports are returned. It does not explicitly state prerequisites like 'block must be saved first', but the input schema already handles that. Overall, it is sufficiently complete for correct invocation and 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 83%, so the schema already documents the parameters well; the baseline is 3. The description adds conceptual context about why observations matter (measuring the gap left by the grid model) and what the two corrections respectively address, but it does not add detailed parameter-level semantics beyond what the schema already states. It is adequate but not compensating for any schema gap.

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 a specific action ('Turn a block's own field reports into a correction on the model') and distinguishes this tool from all siblings by contrasting it with the 9 km grid used by 'every other tool here.' The return of two distinct corrections (heat bias and days bias) further clarifies its unique purpose. An agent can easily tell this is the tool for farm-specific calibration rather than grid-based estimates.

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 strong contextual guidance by explaining that other tools rely on a coarse grid and cannot capture local features (hedgerow, pond, cold-air outlet), and that this tool's observations measure that gap. This implies when to use the tool, but it stops short of explicitly naming alternative tools or stating 'use X instead when Y'. The guidance is clear enough for an agent to infer the appropriate scenario.

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 provided, the description carries the full burden of behavioral disclosure. It explains the return value semantics (sats available for certifying purchases), the consequence of a zero balance (top-ups cannot be certified), and a clarifying trait (operator's own funding, free). It does not explicitly state the operation is read-only, but 'Check' implies non-mutating, and no side effects are mentioned; a 4 is warranted for covering the key behavioral aspects.

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 four sentences, each earning its place: purpose, return value, consequence+next step, and ownership distinction. It is front-loaded with the core action and avoids redundancy or filler. The structure is logical and compact.

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

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

For a zero-parameter tool with an output schema present, the description covers everything an agent needs: what the value represents, what happens when it is zero, the required follow-up action, and a caveat to prevent misuse. It is complete for correct invocation and decision-making.

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 has zero parameters and the input schema is empty, so there is no parameter ambiguity to resolve. Schema description coverage is trivially 100%. The description adds no parameter details, but none are needed, so the baseline 4 for zero-parameter tools 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 opens with a specific verb and resource: 'Check this operator's tax balance at the Authority.' It clearly differentiates this from the sibling goodearth_check_balance by stating 'This is the operator's own funding — not a patron balance.' This leaves no ambiguity about which balance is being checked.

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 clear context for when to use the tool: it returns the sats available for certifying patron credit purchases, and states that when the balance reaches zero, the operator must call purchase_credits on the Authority. It also explicitly warns against confusing this with a patron balance. However, it does not explicitly name alternative check tools like goodearth_check_balance or state 'use this instead of X,' so it stops short of full exclusion 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?

No annotations exist, so the description carries the burden. It discloses two non-obvious behaviors: the call is free ('Free — no credits required') and requires proof of npub ownership to prevent balance enumeration. It doesn't explicitly state read-only semantics, but 'Check' plus the free note make the operation's nature reasonably clear.

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, front-loaded paragraphs: purpose, distinction from sibling, and cost/auth caveats. Every sentence adds information; 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 two-parameter tool with fully described schema and an output schema, the description covers purpose, scope, cost, authentication requirement, and the main alternative. The only minor issue is the imprecise sibling name, which does not undermine calling this tool correctly.

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

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

Schema description coverage is 100%, so the baseline applies. The description adds no new parameter-level detail beyond the schema; the 'proof of npub ownership' sentence reinforces the dpop_token requirement but is already implied by the schema's description.

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?

Opens with a specific verb and object: 'Check a patron's credit balance at this operator.' It then defines that balance as 'patron's spending balance — credits purchased via Lightning for tool calls at this operator' and explicitly distinguishes it from the operator's own Authority balance, so it is not confusable with goodearth_check_authority_balance.

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 states when to use the sibling: 'For the operator's own balance at the Authority ... use authority_check_balance instead.' It also notes the call is free, which is relevant to choosing it. However, the named alternative is not exactly the sibling's name (goodearth_check_authority_balance), introducing a small routing ambiguity.

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 provided, the description carries the burden and does well: it discloses that the call is free, requires proof of npub ownership, and explains the security rationale about preventing credit-grant front-running. It does not detail failure modes or explicitly state read-only behavior, but the purpose verb 'check' and the explanation provide solid transparency.

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 short sentences, each earning its place: purpose, call timing, cost, and auth rationale. The most important operational guidance is front-loaded, and there is no filler or 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?

Given a rich input schema and an output schema, the description supplies the missing operational context: when to call, that it is free, and why the dpop_token proof is required. An agent has everything needed to select and invoke this tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly, including the exact source of invoice_id and the raw JSON form of dpop_token. The tool description adds workflow context but no new parameter-level meaning beyond the schema. 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?

States a specific verb and resource: 'Check the payment status of a Lightning invoice.' This clearly differentiates it from sibling check tools like check_balance, check_price, and check_proof_status. It also anchors the workflow by referencing purchase_credits.

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 says when to call: 'Call after paying the invoice from purchase_credits.' It also gives cost context ('Free — no credits required') and an auth requirement, though it does not name alternative tools or exclusions. This is clear usage guidance without needing to reference 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?

With no annotations provided, the description carries the full disclosure burden. It explicitly states that the operation is free and requires no credits, and the word 'Preview' implies no side effects. It does not mention authentication dependencies such as npub or dpop_token, but the cost-related behavior that matters most 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?

The description is concise, front-loaded with the core purpose, and every sentence adds value: what it shows and that it is free. There is no redundancy or 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?

The tool is relatively simple and has an output schema, so return-value documentation burden is reduced. However, the description lacks any usage context around authentication parameters and does not compare against sibling pricing tools. It is adequate but not fully complete for an agent unfamiliar with the environment.

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 50%; tool_id and tool_kwargs are documented in the schema, but npub and dpop_token are left undocumented. The description adds no parameter-level context, so it does not compensate for the gap. This is a missed opportunity to explain connection/auth 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 uses a specific verb ('Preview the effective cost of a tool call') and clearly names the resource and scope: base cost plus constraint effects such as discounts, free trials, and surge pricing. This differentiates it from related lookup tools like goodearth_get_pricing_model by focusing on the realized, after-constraint price.

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 the use case clear: preview costs before executing a call, and emphasizes this preview is free with no credits required. It does not name alternative tools or explicitly state when not to use it, but the context is strong enough for an agent to decide appropriately.

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 provided, the description carries the full burden and does well: it states the operation is free, has no side effects, does not evict the cache, and does not touch relays. This goes beyond the name and gives the agent confidence about safety.

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: the purpose is front-loaded, the usage context follows, and side-effect disclosure closes it. No filler or redundancy.

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

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

For a low-complexity status-check tool with an output schema and fully documented parameters, the description covers purpose, usage timing, and behavioral guarantees. Nothing essential is missing.

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

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

Schema description coverage is 100%, and both parameters already have clear descriptions in the schema. The tool description adds useful context about the dpop_token being previously cached, but it does not substantially enrich parameter semantics beyond the schema.

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

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

The description states a specific verb and resource: check whether a previously-cached dpop_token is still valid. It distinguishes this tool from other check_* siblings by tying it to the npub-proof flow and even names its analogue, check_oauth_status.

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 clear context for when to call this tool: before a paid call to avoid wasting credits on a guaranteed failure. It references check_oauth_status as the corresponding flow, though it could more explicitly say 'use that for OAuth tokens'.

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 are provided, so the description carries the burden. It discloses that the season curve and frost record are shared across plantings, that one call answers the whole block, and that geometry travels once if saved with block_save. It doesn't mention error behavior for ambiguous block matches, but the schema does. It also doesn't state whether this is a read-only operation, but the description's framing ('Returns...') implies a read. Given no annotations, this is reasonably transparent.

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 well-structured: a one-line summary, then a clear breakdown of what is returned, then a practical usage note. Every sentence earns its place. It is front-loaded with the core purpose and adds efficiency context without bloat.

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

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

The tool has an output schema, so return values are covered there. The description explains the core behavior, the shared-curve optimization, and the block reference flexibility. It doesn't explicitly state prerequisites like needing to save a block first, but the block parameter description covers that. It also doesn't mention what happens if the block is not found or if plantings are invalid, but the schema and error listing hint at it. Overall, it is complete enough for an agent to call 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 coverage is 80%, so the schema already documents most parameters. The description adds meaning for the 'block' parameter by explaining how to reference a block (id, name, alias, unique partial name) and the ambiguity error behavior. It also clarifies the 'plantings' structure with an example. The 'npub' and 'dpop_token' parameters are not described in the description, but the schema covers them. The description adds value beyond the schema for the key 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 clearly states what the tool does: it returns, per planting, heat accumulated, projected completion date, and a frost verdict. It names the resource (block plantings) and the specific outputs. It also distinguishes itself from siblings by emphasizing one call answers the whole block, which differentiates it from per-planting or per-block tools.

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

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

The description explains when to use it: when you need to know where every planting on a block stands and whether it finishes before frost. It also gives a strong usage hint: one call covers the whole block, so asking about eight beds costs one round trip. It doesn't explicitly name alternatives or exclusions, but the context is clear enough.

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 provided, the description must disclose behavior alone. It explains that the answer is a margin (season left after crop finishes) and notes that requirements are user-provided, not published agronomy. It does not mention that blocks must be saved first (which is in the schema for 'block') or any side effects, but it does add context about the calculation method and variability of degree-day figures.

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 somewhat verbose with rhetorical questions and conceptual framing, but it is front-loaded with the key purpose and margin concept. The added context on variability and user-supplied requirements is useful but could be more concise. Overall, it is structured with paragraphs that build understanding without excessive fluff.

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 complexity of the tool (computed margin, user-defined requirements), the description covers the main concepts and prerequisites sufficiently. It mentions that blocks must be saved first, but does not explain the output schema in detail (though output schema exists separately). The description is complete enough for an agent to understand the tool's value and how to structure input, though a note about overlapping blocks could be clearer.

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 schema covers most parameters, but the description adds important context: 'block' can be an id, name, or alias, and that geometry is saved via block_save. It also explains the structure of 'crops' with optional fields. This add value beyond the schema, especially for the 'block' param and the purpose of 'crops'.

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 the tool evaluates crop suitability on a specific ground block, computing frost-free window and heat accumulation to judge each crop's requirements. It distinguishes itself from a simple lookup and from siblings like 'crop_gdd_status' or 'tree_suitability' by emphasizing the margin concept and ground-specific computation.

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

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

The description explains when to use it: when you need to know if crops will finish on a specific block, and emphasizes it is not a general lookup. It implies prerequisites (saving a block first) but does not explicitly mention alternative tools or exclusions, though the distinction from 'crop_gdd_status' is implied by the margin focus.

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 it delivers: it discloses cascading deletion to patron redemptions, the no-op behavior for chain references, Studio warnings for orphans, and the operator/proof requirement. This is thorough behavioral disclosure for a destructive 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?

Four short sentences, front-loaded with the core action. Each sentence adds essential information: the action, the cascade, the no-op reference behavior, and the authorization constraint. No wasted words.

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 destructive tool with no annotations and an output schema, it covers the essential behavioral and authorization context well. The main gap is the dpop_token parameter: what it is, where it comes from, and how it relates to 'requires proof' is left unspecified.

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 0%, so the description must compensate. It mentions coupon_id in passing but does not define it as the identifier of the coupon to delete. dpop_token is never named or explained; 'requires proof' only hints at an authentication token. Parameter meaning is inadequately covered.

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: 'Delete a coupon.' The tool is clearly distinguished from sibling coupon operations like mint_coupon, redeem_coupon, update_coupon, and list_coupons by its destructive action. The cascade and operator restriction further narrow its purpose.

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

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

Gives a clear authorization constraint: 'RESTRICTED to operator — requires proof.' This implies when the tool may be used but does not explicitly contrast it with alternatives like forget_coupon or state when not to use it. Usage context is implied rather than fully specified.

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 provided, the description fully carries the behavioral burden. It discloses idempotency (already-absent fields report 'removed: false' without rewriting the vault), the destructive nature ('as destructive as a write'), the proof requirements (nsec-signed kind-27235 or cached dpop_token), and the operator-only restriction. It also clarifies the field-keyed-on-vaulted-not-template behavior. This is comprehensive transparency.

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 well-structured and front-loaded with the core action in the first line. Each subsequent sentence adds essential context (use case, behavior, restrictions, idempotency, destructive nature). It is slightly verbose, but every clause earns its place. A minor reduction could tighten it, but it remains concise relative to the information conveyed.

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 tool's complexity (destructive operation, auth requirements, idempotency, field semantics), the description covers all necessary aspects. It explains what the tool does, when to use it, its behavioral guarantees, and its constraints. Since an output schema exists (indicated by 'Has output schema: true'), the description need not detail the return format. Nothing critical 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 coverage is 100% for both parameters, so the baseline is 3. The description adds meaningful nuance beyond the schema by explaining that the delete is keyed on what is vaulted rather than the current template, which applies directly to the 'field' parameter. It also contextualizes the 'dpop_token' as the operator proof, though the schema already calls it 'Operator proof'. This added semantic depth justifies a 4.

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 ('Remove'/'Delete'), a precise resource ('single operator secret field'), and explicitly distinguishes it from 'forget_credentials' (wipes the whole row). It also differentiates from the sibling 'delete_patron_credential' by restricting to operator. This makes the purpose unambiguous and distinguishes it from nearby tools.

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 concrete use cases ('retire a leftover after an SDK cutover') and explicitly contrasts with the alternative 'forget_credentials' for full re-delivery. It also specifies the constraint that only operators can use it and that patron proofs are rejected, giving clear when-to-use and when-not-to-use guidance.

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

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

The description discloses that it is a write to a sensitive credential vault, requires proof of ownership, and is free. It also states that other fields are unaffected. However, it does not mention reversibility, idempotency, or error behavior. With no annotations, this is a moderate disclosure but not exhaustive.

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 concise, with the purpose stated in the first line and additional details in a second sentence. It avoids redundancy, front-loads the primary action, and every sentence adds value without waste.

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

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

The description covers the essential context for a delete operation: what it does, its scope (single field), cost, and authentication requirement. Since an output schema exists, return values are not needed. It lacks details on idempotency or error handling, but these are minor given the full parameter schema and clear scope.

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 schema already fully documents all three parameters (npub, field, dpop_token) with detailed descriptions, including dpop_token's format and constraints. The tool description does not add any additional parameter-specific guidance beyond what the schema provides, so it meets the baseline for high schema coverage.

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

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

The description clearly states the tool removes a single patron credential field, distinguishing it from updating or forgetting all credentials by specifying 'one field' and 'without affecting other fields'. It also identifies the resource as 'patron credential vault' and implies a write operation.

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 context that this is a write operation requiring proof of npub ownership and is free, but it does not explicitly name alternatives or conditions for when not to use it. An agent can infer usage from the description, but it lacks explicit routing to sibling tools like goodearth_update_patron_credential or goodearth_forget_credentials.

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 so thoroughly: it discloses that wetness is estimated, never measured, that the estimation source is named, and that the service does not provide pathology expertise or treatment advice. This is substantial behavioral context beyond a simple summary.

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 opening sentences are well front-loadednewlinewith the result summary, but the 'dry August' and 'degree days' section is illustrative rather than essential. Woven-in metaphor adds readability but lengthens the definition; it is appropriately sized for domain complexity but not maximally 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?

Given the output schema exists and schema descriptions are rich, the description covers the domain-specific caveats an agent needs: estimation uncertainty, model limited set, and non-advice boundary. It could mention authentication or billing implications, but the npub parameter already covers billing in 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 description coverage is 80%, so the schema already documents parameters like block, models, and season. The description adds conceptual meaning but does not clarify parameter formats or edge cases beyond what the schema states. It earns the baseline 3 without pushing higher.

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 ('Returns the estimated wet hours', 'what the disease models make of them') and clearly enumerates the outputs: infection periods, criteria met, and forecasted wet stretch. It is unmistakably distinct from siblings like frost or pest tools through its focus on leaf wetness and disease models.

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

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

The description explains what the tool does and what it does not do (no treatment recommendations), but it never states when to prefer this tool over alternatives such as goodearth_pest_threshold or goodearth_crop_suitability. No explicit exclusions or sibling routing is provided.

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 this well. It discloses that wetness is ESTIMATED, never measured, that ET0 is included to explain drying, that this is 'Conditions only', and explicitly says Good Earth publishes no agronomy. It also defines the dew-off hour precisely.

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 informative and every substantive paragraph earns its place, but the opening line is poetic rather than functional, so the core purpose is not front-loaded. It is longer than strictly necessary, though still well-organized into 'what', 'returns', and 'limitations'.

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 complex forecasting tool with an output schema, the description is remarkably complete: it explains the question answered, the time horizon (ten days ahead), the per-day fields, the estimation caveat, and the scope boundary. Nothing needed to correctly invoke and interpret the result 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 coverage is 67%, and the description adds no parameter-level meaning. The block and npub parameters are already well described in the schema, but dpop_token remains undocumented and the description does not compensate for that gap.

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: it 'Answers "is it dry enough yet?"' for a grower planning to cut flowers, pick, mow or make hay, and lists the exact outputs (dew-off hours, dry-day runs, rain hour, ET0, VPD). This is clearly distinguishable from sibling window/frost tools by content even without naming 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?

It gives explicit context for when to call the tool (grower planning to cut flowers, pick, mow or make hay) and clarifies limitations ('Conditions only'). However, it never explicitly names alternatives or tells an agent when not to use this tool versus related window tools.

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 provided, the description carries the full burden and does well: it discloses that the action is non-destructive, reversible (re-redeemable), free, and requires proof of `npub`. Some ambiguity remains about what 'proof of npub' means operationally, but the core side effects and persistence of the coupon are clearly stated.

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, each earning its place: the primary action, the key caveat about cosmetic effect, and the cost/auth note. It is front-loaded and free of fluff.

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 simple schema, the output schema presence, and no annotations, the description is largely complete: it explains the effect, non-destructiveness, re-redeemability, cost, and auth requirement. It could add a bit more about prerequisites or failure modes, but those are not essential for this straightforward operation.

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 0%, so the description must compensate. It gives meaning to `npub` (patron identity with proof requirement) and `coupon_id` (the coupon being removed) implicitly, but it says nothing about the optional `dpop_token` parameter. This is partial compensation, not full coverage.

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

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

The description states a specific action ('Remove a coupon from this patron's redemption list') with a clear resource and subject. It distinguishes itself from the sibling `goodearth_delete_coupon` by explicitly saying the coupon still exists at the operator, so an agent can tell these apart.

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 clear context for when to use this tool: when the goal is only to remove a coupon from a patron's list, not to permanently delete it. The 'Cosmetic only' qualifier implies when not to use it, though it does not explicitly name the alternative tool or provide an explicit when-not statement.

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

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

There are no annotations, so the description carries the full behavioral burden. It clearly discloses that the operation deletes vaulted credentials, always requires proof of npub ownership, and is destructive. This is strong transparency for a mutating 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?

The description is three tight sentences with no filler. The action and destructive consequence are front-loaded, and the operator/patron nuance is concise. Every sentence adds useful information.

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

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

For a 3-parameter tool with a rich output schema and detailed dpop_token documentation in the schema, the description is largely complete: it identifies what is deleted, how to pick npub, and the required proof. The only notable gap is the lack of guidance distinguishing this tool from the delete_* sibling tools.

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

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

The input schema already covers all three parameters at 100%, so the baseline is 3. The description adds value by explaining the operator/patron distinction for the npub parameter and reinforcing that the deletion destroys credentials, going beyond the schema's generic descriptions.

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 has a clear verb and resource: 'Delete vaulted credentials for a specific service and npub.' It also adds useful operator-vs-patron context. However, it does not differentiate this tool from sibling deletion tools like goodearth_delete_operator_credential and goodearth_delete_patron_credential, so it earns a 4 rather than a 5.

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

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

The description gives within-tool guidance about which npub to pass for operator vs patron credentials, but it never states when to choose this tool over the sibling delete_* tools or when to avoid it. With multiple credential-deletion siblings present, the lack of explicit alternatives leaves the agent to infer selection criteria.

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 provided, the description fully carries the behavioral burden: it discloses irreversibility, the difference from soft-delete, immediate calendar feed invalidation, preserved patron balance and purchase history, the ability to re-onboard with the same npub, proof-of-npub requirement, and no cost. This is exceptionally transparent for a destructive 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?

The description is front-loaded with the core action and data inventory, and the longer explanations about irreversibility, patron status, auth, and pricing all earn their place. A bit of rhetorical flourish could be trimmed, but it does not obscure the operational contract.

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 destructive operation with no annotations, the description supplies all essential context: destructive scope, side effects, exclusions, authentication requirements, cost, and post-delete behavior. An output schema exists for return values, so no material information is missing.

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

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

The schema already documents npub and confirm with clear descriptions. The tool description adds semantic value by requiring proof of the npub and noting that the same npub can sign in again afterward. The dpop_token parameter remains undocumented in both the schema and description, leaving a small gap at 67% coverage.

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

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

The description opens with a precise destructive verb and resource: 'Delete every block you have here, and everything recorded on them.' It then enumerates the concrete data categories affected and explicitly contrasts itself with other removals that retain history, making its purpose unmistakable.

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 clearly establishes the intended scenario—a grower who asks to be forgotten and expects a true delete rather than a soft delete—and differentiates itself from 'every other removal in this service' that keeps history. It does not name sibling alternatives or provide an explicit when-not-to-use list, so it stops short of 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 provided, the description carries the burden of behavioral disclosure. It explains the tool's analytical approach (comparing last ten seasons, terrain spread, coldest ground rather than average) and the physical rationale. However, it doesn't disclose side effects, prerequisites beyond saving a block, or what happens if the block isn't found, though the schema covers the error case partially.

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 compact and front-loaded with the core question ('when frost arrives... and whether it is coming this week'), then adds the analytical detail and the physical rationale. Every sentence earns its place, though the final sentence about cold air drainage is explanatory rather than operational, which is slightly more than strictly necessary.

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 output schema exists and the tool is a read-style query, the description covers the key context: what data is returned (first-frost dates, spread, nightly assessment), the coldest-ground perspective, and the block reference mechanism. It doesn't mention billing/credits or the dpop_token, but the schema covers npub's billing purpose. The description is complete enough 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 coverage is 67%, and the description adds meaningful context for the 'block' parameter by explaining how to reference a saved block (id, name, alias, unique partial name) and that blocks may overlap. The npub and dpop_token parameters are not described in the description, but the schema covers npub's purpose. The description compensates well for the block parameter's semantics.

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 the tool answers when frost normally arrives on a specific ground and whether it is coming this week, returning first-frost dates, terrain spread, and night-by-night forecast for the coldest ground. It distinguishes itself from generic weather tools by emphasizing the coldest-ground perspective, though it doesn't explicitly name a sibling 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?

The description implies when to use it: when you need frost timing for a specific saved block, and it explains the terrain-based reasoning (cold air drains to low ground) that justifies the coldest-ground focus. It doesn't explicitly state when not to use it or name alternatives, but the context is clear enough for an agent to select it for frost-related queries.

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 it does clarify that this is a non-mutating 'Returns' operation with forecast and projection behavior. It does not disclose billing/auth implications, prerequisites such as block_save, or latency/error behavior, though the schema partially covers billing and prerequisites.

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 compact and front-loaded: one sentence for purpose, one for output components, and one for interpretation. All three earn their place, though the interpretive final sentence is a slight luxury rather than essential.

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

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

The tool has an output schema and mostly well-described parameters, so the description need not re-explain returns or param syntax. It is still missing explicit routing guidance and behavioral caveats, and relies on the schema for prerequisites and billing, making it 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?

The schema already covers three of four parameters with detailed descriptions, so the description does not need to repeat them; it adds conceptual context about ground variability ('bench to hollow'). It does not compensate for the undocumented dpop_token field, leaving that parameter's meaning to inference.

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 opening 'Growing degree day accumulation across a region, season to date' clearly specifies the metric and temporal scope, and the next sentence enumerates the returned components. It does not explicitly contrast with sibling tools like crop_gdd_status or soil_temp_projection, so it stops short of a 5.

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

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

The description implies when to use it by emphasizing that the spread 'decides whether one planting date serves the whole block,' which gives decision context. However, it never states when not to use it, names alternatives, or specifies conditions that would route to another tool.

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

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

With no annotations provided, the description carries the behavioral transparency burden. It discloses that the operation is a read, is free and public, returns latest metadata fields, and fallbacks to an empty profile if none exists. It does not cover error handling, relay behavior, or the meaning of an omitted npub, which prevents a 5.

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

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

The description is two short sentences with no fluff, front-loading the core purpose before adding cost and return behavior. 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 one-parameter read tool with an output schema, the description is nearly complete: it covers purpose, public access, no-proof requirement, returned fields, and empty fallback. The only notable gap is the optional/npub default behavior, since the input schema marks it as not required.

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

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

The description identifies the sole 'npub' parameter as the subject being read and lists the returned metadata fields, adding some meaning beyond the bare schema. However, schema coverage is 0% and the schema marks npub optional via default '', while the description never explains what happens when npub is omitted or empty.

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?

Description opens with a specific verb and resource: 'Read an npub's public Nostr profile (NIP-01 kind-0 metadata),' which clearly distinguishes it from the write-related sibling goodearth_publish_nostr_profile. It avoids tautology and tells an agent exactly what operation is performed.

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 clear context: 'Free, no proof — the data is already public on relays,' which tells the agent when this tool can be invoked without authentication. It implies a read-vs-write distinction from sibling publish_nostr_profile but does not explicitly name alternatives or when-not conditions, so it stops short of 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 provided, the description carries the full burden of behavioral disclosure. It usefully explains that the tool generates a proof rather than mutating data, but it does not explicitly state that the operation is read-only, whether authentication is required, or what happens if the patron's balance was not included in the snapshot.

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, well-structured sentence that front-loads the action and resource, then provides the necessary context. There is no redundant wording or repetition of the title, making it highly 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?

The tool has only two required parameters, both fully described in the schema, and an output schema exists, which reduces the need to document return values. The description explains the tool's purpose sufficiently for an agent to invoke it correctly, though it could be slightly more complete by noting where the notarization_id originates.

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. Both parameters are minimally documented in the schema ('Nostr public key' and 'notarization record ID'), and the description adds little beyond linking them to the patron balance and notarized snapshot context. This is adequate but does not elevate the semantics further.

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 ('Generate') and a precise resource ('Merkle inclusion proof that a patron's balance was included in a Bitcoin-notarized snapshot'). This clearly differentiates it from related siblings such as goodearth_list_notarizations, goodearth_notarize_ledger, and goodearth_check_proof_status, because the proof-generation purpose is explicit and unique.

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 should be used when a Merkle inclusion proof for a patron's balance in a notarized snapshot is needed. However, it does not explicitly state when to use this tool over alternatives, nor does it mention any exclusions or prerequisites such as first listing notarizations to obtain a notarization_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?

With no annotations provided, the description carries the full disclosure burden. It goes beyond a label by specifying what the report shows and that it includes delivery instructions for missing values. 'Report' and 'Shows' strongly imply a read-only operation, though it stops short of describing data sources or edge cases.

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

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

The description is two tight sentences: the first front-loads the core action, and the second adds output detail, the sibling distinction, and the cost note. There is no filler or repeated schema information.

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

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

For a zero-parameter report backed by an output schema and no annotations, the description covers purpose, output scope, sibling distinction, and cost. It doesn't explain the mechanism or data source, but those are not necessary for correct invocation, so it is nearly 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?

The tool has zero parameters and the schema coverage is trivially 100%, so the baseline is 4. The description correctly adds no parameter syntax details; the phrase 'this operator' indicates the tool operates against ambient operator context rather than requiring an explicit argument.

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 opens with a specific verb-resource pair ('Report this operator's configuration readiness') and then enumerates exactly what the report contains: which settings are configured, which are missing, and how to deliver each missing value. It also distinguishes itself from the nearest sibling, get_patron_onboarding_status, so an agent can tell the two apart.

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 explicitly gives the when-not and the alternative in one clear sentence: 'For patron-level credential status, use get_patron_onboarding_status instead.' It also signals there is no cost barrier with 'Free.' This is explicit guidance for choosing between 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states values are never exposed, the operation is free, proof of npub ownership is required, the field list itself is sensitive, and delivered_at may be null for older vaulted secrets. This gives an agent essential behavior and safety context beyond a simple read operation.

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 compact and front-loaded with the core message ('List stored patron credential field names (not values)'), followed by concise details about return data, cost, and authentication. Every sentence contributes meaningful information without redundancy.

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

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

Given the tool's moderate complexity, the presence of an output schema, and the lack of annotations, the description covers all essential aspects: what it lists, what it does not return, cost, auth requirement, and why the data is sensitive. Nothing an agent needs to call it correctly is missing.

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

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

The input schema already provides 100% coverage with detailed parameter descriptions, so the baseline is 3. The description adds context about npub ownership and sensitivity, but it does not need to explain parameter syntax further because the schema is thorough.

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 uses a specific verb ('List') with a clear resource ('stored patron credential field names') and explicitly distinguishes names from values. It also states the tool's purpose: verifying which fields are configured and their age, which separates it from sibling mutation tools like update_patron_credential and delete_patron_credential.

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 clear context for when to use the tool: 'use this to verify which fields are configured and how old each one is.' It does not explicitly mention alternatives or exclusion conditions, but its use case is specific enough that an agent can decide when it applies.

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 provided, the description carries the behavioral disclosure burden. It adds valuable context: the tool is free, requires proof of npub ownership, and treats credential presence as sensitive. It does not explicitly state side-effect freedom, but 'Report' and 'shows' strongly imply a read-only operation.

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 compact and front-loaded: the core purpose appears in the first sentence, and every subsequent sentence adds distinct value (service behavior, cost, auth requirement). No filler or redundant restatement of the schema.

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

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

For a two-parameter read-only status tool with an output schema, the description covers the essential operational context: service-type differences, cost, and authentication. It could be slightly more complete by pointing to related credential-management siblings, but that is more of a usage-guideline refinement.

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 (patron_npub, dpop_token) are already well-documented in the input schema. The description adds only the contextual mention of proof-of-ownership, not new parameter-level semantics, so the baseline of 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 opens with a specific verb and resource: 'Report a patron's credential readiness for this operator.' It then distinguishes patron-level status from sibling goodearth_get_operator_onboarding_status and explains service-specific meanings, leaving little ambiguity about what this tool does.

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 clear context: it reports readiness, explains the two service categories (set-once vs OAuth2), and notes the proof-of-ownership requirement. However, it never explicitly references alternatives like goodearth_get_patron_credential_fields or states when not to use this tool, so exclusions are only implied.

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 transparency burden and does well. It discloses that the call is free, that a missing model causes self-initialization of a scaffold with all registered tools at 0 sats, and that output contains 'No economic data from code.' This surfaces a meaningful side effect and a likely misconception, going well beyond a terse 'Get pricing model'.

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 with no filler. The core purpose is front-loaded first, followed by two high-value clarifications about cost and initialization behavior. Every sentence earns its place.

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

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

For a zero-parameter tool with an output schema, this description is complete. It covers what is fetched, for whom, the cost, the edge case of no existing model, and the nature of the returned data. Nothing needed to safely invoke the tool is missing.

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

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

The tool has zero parameters and the schema already documents this fully with 100% coverage. The baseline for 0 params is 4, and the description appropriately focuses on behavior rather than parameter details, since there are no parameters to clarify.

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

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

The description clearly states a specific verb and resource: 'Get the active pricing model for this operator.' It differentiates from the many sibling tools by naming the exact object returned and adding delimiting facts like 'Free' and 'No economic data from code.' An agent can distinguish this from set_pricing_model, reset_pricing_model, and check_price without guessing.

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 intended use is implied: call this when you need the active pricing model for the current operator. However, it does not explicitly say when to prefer this over alternatives, nor does it mention related siblings like set_pricing_model or reset_pricing_model. It provides context but leaves the comparison to the agent.

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 are provided, so the description carries the full burden. It discloses that the tool is free and has no side effects, includes both ToolIdentity-seeded tools and UUIDs recorded by @paid_tool missing from the registry, and explains the registered:false flag and unregistered array for drift detection. It also explains the canonical-UUID design (mcp_name changes, tool_id stays). This is rich behavioral context beyond a simple 'list' description.

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 longer than strictly necessary, with some redundancy (the unregistered/drift point is made twice, referencing both #174 and #175). However, it is front-loaded with the core purpose and each paragraph adds meaningful context. The repetition of the drift-detection point costs a point, but the structure is otherwise clear.

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

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

For a zero-parameter, read-only listing tool with an output schema, the description is complete. It explains what the output contains, why it matters, how to interpret the registered flag, and the design invariant (tool_id stability). An agent has everything needed to call and interpret this tool correctly.

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

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

The tool has zero parameters, so the schema is trivially complete. The description doesn't need to explain parameters, and it doesn't. Baseline 4 for zero-param tools is appropriate; the description adds no parameter info because there is nothing to add.

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 ('Return') and resource ('canonical (tool_id, mcp_name, …) for every tool the wheel exposes'), and clearly distinguishes this from siblings by explaining it is the authoritative source for tool identity mapping. It also names the consumer (Reconcile) and the purpose (UUID-join against pricing model), which removes any ambiguity about what this tool does.

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 explicitly says when to use this tool: any client that needs to know how the MCP identifies its tools, and specifically Reconcile for UUID-join. It also states what not to do ('no name-based UUID derivation, no guessing'), which is a clear exclusion. This is strong usage 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 provided, the description carries the behavioral disclosure burden. It explicitly states what will be returned (type, category, description, parameter specs) and that no credits are required. The verb 'List' implies a read-only operation, and the cost note adds useful operational context beyond the schema.

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

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

The description is compact and front-loaded: the first sentence states exactly what the tool does, and the second adds return-field details and the cost implication. Every sentence earns its place with no filler or redundancy.

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

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

For a zero-parameter list operation with an output schema, the description is complete. It identifies the domain (pricing pipeline), the returned fields, and the fact that the call is free. An agent has everything it needs to select and invoke this tool correctly.

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

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

The tool has zero parameters, so the description does not need to explain parameter behavior. The schema already reflects this with an empty properties object and 100% schema description coverage. The baseline of 4 for zero-parameter tools 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 uses a specific verb and resource: 'List all available constraint types and their parameter schemas.' It clearly identifies the scope (constraint types usable in a pricing pipeline) and the returned fields, distinguishing it from the many sibling tools without needing to reference 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?

The description gives clear context: this is the tool to discover constraint types and their parameter schemas for pricing pipelines. It also notes that it is free and requires no credits, which is useful for an agent deciding whether to call it. It does not name exclusions or alternatives, but no close alternative is evident among the 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?

No annotations are provided, so the description must carry the behavioral burden. It discloses a meaningful restriction ('RESTRICTED to operator — requires proof'), a sorting behavior ('newest first'), and the presence of a times_redeemed counter with a rendering note about Studio's progress bar. This gives an agent useful information about state and constraints beyond just 'lists coupons.' It stops short of clarifying auth requirements in detail or pagination 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 compact and front-loaded with the primary action and scope, followed by a useful rendering note and a restriction warning. Every sentence carries information. Minor structural inefficiency: the 'RESTRICTED to operator — requires proof' line is arguably central and could have been placed earlier, and the reverse-quoted counter label is a formatting quirk.

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 is presumably covered. For calling it correctly, the agent knows this is an operator-scoped read of minted coupons with a proof requirement. Gaps remain: how to satisfy the proof requirement, whether listing is paginated, and what the exact semantics of 'this operator' are relative to goodearth_list_my_coupons. These are material for a restricted tool, so completeness is only partial.

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 input schema has one parameter (dpop_token) with 0% schema description coverage, so the description would carry the burden in a high-stakes case. However, the description both implicitly and explicitly mentions the operator/proof requirement, which is likely tied to the token parameter. It does not explicitly explain how dpop_token is used or what value to supply, so it provides only partial compensation for the missing schema description.

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+resource ('List every coupon this operator has minted') and includes a sorting detail (newest first). However, the scope is somewhat ambiguous because two sibling tools have very similar names: goodearth_list_my_coupons and goodearth_list_coupons. The description does not explicitly distinguish itself from those siblings, so it is clear but not fully differentiating.

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 that this is for operators minting coupons and notes it is 'RESTRICTED to operator — requires proof.' It does not mention when to choose this over goodearth_list_my_coupons or other coupon-related tools (mint_coupon, redeem_coupon, update_coupon, delete_coupon, forget_coupon). There is no explicit when-to-use or alternative 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 provided, the description carries the full burden of behavioral disclosure. It usefully states that both active and exhausted redemptions are returned, enumerates the possible per-row status values, and notes that the operation is free and requires npub proof. It does not mention pagination or error behavior, but the core behavior is well 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?

The description is concise and front-loaded with the purpose, followed by a compact status vocabulary and a short cost/auth note. Every sentence adds useful information without filler.

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

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

For a simple two-parameter listing tool with an output schema present, this description is nearly complete: purpose, return statuses, and proof requirement are all covered. The main gaps are the role of dpop_token and a clearer word about which sibling tools it should be preferred over.

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 schema description coverage is 0%, so the description must add parameter meaning. It does clarify that npub is the required proof identifier, which is helpful. However, the optional dpop_token is left unexplained, and the description does not fully compensate for the schema's lack of semantic 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?

The description opens with a specific verb and resource: 'List the coupons this patron has redeemed on this operator.' It further clarifies the scope by saying it returns both active and exhausted redemptions. However, it never explicitly distinguishes itself from the sibling goodearth_list_coupons, so sibling differentiation is only 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 description implies its use case: checking a patron's redeemed coupon statuses, with statuses like active and exhausted. It does not explicitly state when to use this instead of alternatives, nor does it mention exclusions, leaving routing decisions to the agent.

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 provided, the burden falls entirely on the description. It only states that the tool lists records and calls them 'recent', but doesn't explain ordering guarantees, time window, side effects, access requirements, or whether the results are derived from the Bitcoin blockchain. The term 'recent' is vague and unquantified.

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 focused sentence with no filler words. It efficiently conveys the core action and resource, front-loading the essential purpose without unnecessary details.

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

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

The output schema and parameter schema cover the technical details, but the description lacks clarification of what 'recent' means (e.g., a default time window) and how it might relate to status values. For a tool with no annotations, this leaves the agent with some ambiguity about the exact result scope, though the basics are sufficient.

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

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

The schema description coverage is 100%, providing clear explanations for both 'limit' and 'status'. The description itself adds no extra meaning to the parameters, so the baseline of 3 applies since the schema already carries the parameter semantics.

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 'List recent Bitcoin notarization records' uses a specific verb and resource, clearly identifying the operation. It is distinct from sibling tools like notarize_ledger (which creates) and get_notarization_proof (which retrieves a single proof), so an agent can easily differentiate 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?

No guidance is given on when to choose this tool over related siblings such as get_notarization_proof or check_proof_status. The description lacks any context for when listing is appropriate versus retrieving a specific proof or creating a notarization.

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 are provided, so the description carries the behavioral disclosure burden. It only says 'Create', which implies mutation, but it does not disclose side effects, uniqueness conflicts, ownership verification, or any constraints beyond the schema. This is a significant gap for a state-changing 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?

The description is a single, tightly worded sentence with no filler. It front-loads the action and object clearly, making it easy for an agent to parse quickly.

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

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

The schema is rich with parameter details and an output schema exists, so the description does not need to explain return values. However, the description omits operational context such as authentication prerequisites, how operator ownership is enforced, and the distinction between this tool and update_coupon. The undocumented dpop_token parameter further contributes to the 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 high at 86%, and parameter descriptions are detailed. The tool description adds no parameter-specific meaning, but the schema already documents name, discount_percent, valid_from, valid_until, total_uses, and uses_per_patron well.

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 the verb ('Create'), the resource ('discount coupon'), and the ownership scope ('operator-owned'). This differentiates it from update, delete, list, and redeem coupon siblings without needing to inspect 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?

The description establishes a clear usage context: creating a new operator-owned coupon. It does not explicitly name alternatives like update_coupon or delete_coupon, but the 'create a new' phrasing provides enough context for an agent to select this tool over its 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?

With no annotations, the description carries the transparency burden and reveals the non-obvious behaviors: 20-per-page results with the true total shown, search expansion beyond the block with a reported search width, counts reflecting observer presence rather than abundance, and zero added judgement. It also names iNaturalist as the source, adding useful context.

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

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

The core sentence is front-loaded and bold lead-ins group related caveats, making the long description scannable. The illustrative Vermont/hayfield/roadside examples are useful for understanding the results, but they make the description more narrative than strictly necessary.

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 search tool with an output schema and high-coverage input schema, the description explains everything an agent needs to know beyond the schemas: pagination, true total, geographic widening, observer-bias caveat, and non-judgmental output. The absence of annotations is fully compensated on the points that matter for calling and interpreting this tool.

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

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

Schema coverage is high (86%) and the schema already gives strong descriptions for block, kingdom, q, page, npub, and with_lifecycle. The prose mainly reinforces page size and the meaning of the totals; it does not add new meaning or syntax for individual parameters, so the baseline of 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 opening sentence states the exact action and resource: 'Search what is actually recorded near this ground, a page at a time.' It also distinguishes the tool from its siblings by explicitly saying that every other tool answers only for the drawn ground, while this one widens to the surrounding country.

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 tells an agent when to choose it: 'This replaces asking for a whole catalogue' and instructs 'search, twenty to a page.' It also gives a when-not by stating that every other tool answers strictly for the drawn ground and warning that no pest, weed, planting suitability, etc. judgement is made, which prevents misrouting and misinterpretation.

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?

Given there are no annotations, the description carries the full burden. It discloses the operation's nature (background, slow), the cost (free), and the access level (operator-only). It doesn't detail what happens to existing notarizations or whether it can be run multiple times, but for a no-parameter tool, these are minor. The description adds value beyond the schema.

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

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

The description is two sentences, front-loaded with the core action and purpose. The second sentence clarifies usage context. Every sentence is essential and provides critical information for the agent to decide and invoke correctly.

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

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

The tool is simple (no parameters) and has an output schema, so the description covers the main behavioral aspects: what it does, who can use it, how long it takes, and cost. Minor gaps include any retry behavior or side effects, but for a zero-parameter background task, this is adequate.

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

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

The input schema has no parameters, so the description has no parameter semantics to clarify. The baseline for 0 params is 4. The description doesn't need to add parameter details, but it does not explain the output format either. However, the output schema is present, so return values are covered.

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 the action: build a Merkle tree of patron balances and submit the root to Bitcoin via OpenTimestamps. This is specific and distinct from other notarization-related tools like get_notarization_proof or list_notarizations. The resource (ledger) and purpose (notarization) are clear.

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 explicitly marks this as an operator-only background task, which tells the agent when to use it (only for operators, as a background operation). It also provides timing expectations (1-6 hours for confirmation) and notes it's free, which helps the agent decide if it's appropriate. No alternatives are named, but the use-case is clear enough to distinguish.

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 are provided, so the description carries the full burden. It discloses that the tool is 'Free' (likely no cost) and that it describes the ecosystem, but it does not state whether it makes network calls, requires authentication, has rate limits, or what kind of output to expect. The behavior is mostly opaque beyond the basic action.

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 extremely short: 'Describe the DPYC ecosystem via the Oracle. Free.' It is concise and front-loaded, but the second sentence is a fragment and the phrase 'via the Oracle' is unclear. It earns points for brevity but loses some for cryptic wording.

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 there is an output schema, the return value may be partially documented elsewhere, but the description still lacks context about what 'the Oracle' is, what 'DPYC ecosystem' means in practice, and what an agent should expect. For a general informational tool with no annotations, this is thin but not completely empty.

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 has zero parameters, so there is no parameter semantics burden. The description does not need to explain parameters, and the schema already confirms an empty object. Baseline 4 is appropriate for a no-parameter tool.

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 says 'Describe the DPYC ecosystem via the Oracle. Free.' It identifies a verb ('describe') and a resource ('DPYC ecosystem'), but 'via the Oracle' is vague and doesn't clarify what the Oracle is or what kind of description will be returned. It is distinguishable from siblings only in that it is a general about/overview tool, but the wording is too loose to be fully clear.

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

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

There is no guidance on when to use this tool versus the many sibling tools. The word 'Free' hints that it may be a no-cost informational call, but there is no explicit context, no exclusions, and no mention of alternatives. An agent would have to infer that this is a general-purpose overview tool.

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

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

With no annotations, the description must carry behavioral disclosure. 'Get' implies a read-only query and 'Free' implies no financial side effects, but nothing else is disclosed, such as authentication requirements, rate limits, or whether the value can change over time. For a zero-parameter getter this is mostly acceptable, though not exhaustive.

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

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

The description is two short sentences and every word earns its place. It front-loads the core purpose and adds the 'free' disclosure without unnecessary elaboration or boilerplate.

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

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

For a zero-parameter tool with an output schema, this description covers the essential facts an agent needs to invoke it correctly: what resource is being fetched and that no cost is incurred. The only missing contextual detail is when to prefer it over the price-related siblings, but that has already been scored under usage guidelines.

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 has zero parameters and the schema's coverage is 100%, so there are no parameter semantics to explain. A 4 is the correct baseline because the description is not required to compensate for any undocumented 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?

The description states a very specific verb and resource: 'Get the current DPYC certification tax rate.' This is immediately distinguishable from siblings like check_price, get_pricing_model, and set_pricing_model, so an agent can identify exactly what this tool returns without opening 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?

No guidance is given for when to prefer this tool over alternatives, and no context is provided for when it should not be used. 'Free' hints at lower cost but does not explain how this relates to the broader pricing and coverage tools available in the sibling group.

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 are present, so the description must carry the full behavioral burden. The word 'Get' implies a read-only action and 'Free' implies no cost, but there is no explicit mention of authentication needs, side effects, or rate limits. This is minimal disclosure.

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 extremely concise: two short sentences, the first stating the action and resource, the second a one-word benefit. No filler or repetition, and the main purpose 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 zero-parameter, informational retrieval tool with an output schema, the description covers the essentials: what it retrieves and the cost. It does not mention whether login or other prerequisites are needed, but the schema and simplicity make it largely 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?

The tool has zero parameters and schema description coverage is 100%, so there are no parameter semantics to clarify. Baseline of 4 applies because the input schema is fully defined and the description adds nothing extra, which is appropriate for a parameterless tool.

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 uses the verb 'Get' with a direct object 'onboarding instructions' and names the resource 'the Oracle', clearly indicating what the tool does. The title 'How To Join' and the reference to 'DPYC onboarding' sufficiently distinguishes this from sibling tools like oracle_about or oracle_network_advisory.

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 does not give any when-to-use guidance, exclusions, or alternatives. It only states the function and that it is free, leaving the agent to infer that it should be used when onboarding instructions for DPYC are needed. No comparison to other Oracle-family tools is provided.

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 provided, the description carries the full transparency burden, but it only adds the behavioral trait 'Free' and relies on the verb 'look up' to imply read-only behavior. It does not mention authentication, error behavior, side effects, or any other operational characteristic an agent might need.

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 extremely concise and front-loaded with the main purpose, followed by a short cost note. It contains no fluff or redundant wording and efficiently conveys the core action.

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 a one-parameter tool with no annotations and the presence of an output schema, the definition misses important context: when to use this specific lookup tool versus the many similar siblings, expected behavior for unknown npubs, and format constraints. It is minimal but not complete enough for an uncertain agent.

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 input schema provides no description for the 'npub' parameter (0% coverage), so the description is the only textual hint. Saying 'by npub' clarifies that npub is the search key, but it does not provide format, example, constraints, or how the value is interpreted, leaving an agent with incomplete information for building a valid request.

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 uses a specific verb ('Look up') and resource ('DPYC community member') and identifies the lookup key ('npub'). It clearly establishes what the tool does, but it does not differentiate this tool from siblings such as goodearth_get_nostr_profile or goodearth_list_canonical_identities.

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 offers no use-case guidance, conditions, prerequisites, or exclusions relative to the many sibling tools. It simply restates the tool's function without explaining when to choose it over 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?

With no annotations, the description carries the behavioral burden: 'Get' signals a read-only operation and 'Free' indicates no payment is required. The description does not mention authentication or failure behavior, though for a zero-parameter read tool this is a minor gap.

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 deliver the essential information with no filler. The main action is front-loaded before the cost qualifier.

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

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

For a zero-parameter read operation with an output schema present, the description covers what the tool does and its cost. It relies on the tool name and context for what an 'Oracle advisory' is, but that is acceptable given the low 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?

The input schema has zero parameters, so there is nothing for the description to add. The description correctly avoids inventing parameter details.

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 uses a specific verb ('Get') and resource ('active network advisories from the Oracle'), making the tool's function immediately identifiable. It is distinct from sibling Oracle tools like oracle_about or oracle_lookup_member.

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 context is clear: call this when you need currently active advisories from the Oracle. It does not explicitly compare to sibling tools or state when not to use it, so it misses the top score but is not misleading.

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?

Since no annotations are provided, the description carries full responsibility for disclosing behavior. It does so effectively: it states the tool 'Read[s] from the USA-NPN degree-day forecasts' rather than a local list, explaining external dependency. It discloses that some layers carry accumulated heat and are 'counted and named as unreadable rather than rendered as dates,' and that insect observations come from iNaturalist with possible search widening to surrounding country. These are meaningful behavioral caveats that affect interpretation. It implicitly signals a read-only operation, though it does not explicitly mention authentication or side effects, which are covered by schema parameters.

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 verbose, spanning three paragraphs. It front-loads the purpose in the first sentence, then explains data provenance and quirks. While every paragraph adds useful context about data reliability, the text is longer than necessary and could be tightened. It is not excessively padded, but it is not concise either. It earns a 3 for being structured and informative without being wasteful.

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 query tool with an output schema (the signal indicates one exists), the description does not need to explain return values. It explains the data sources, the interpretation caveats (unreadable heat sums, iNaturalist observation widening), and the block parameter is thoroughly described in the schema. It does not mention billing or npub, but those are captured in the schema's npub description. Overall, the tool is adequately specified for an agent to understand what it does, how data behaves, and how 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?

The tool description does not discuss any parameters; it relies entirely on the input schema. Schema coverage is 67% (two of three parameters have descriptions). The block parameter description is detailed, explaining how to reference saved blocks and the behavior on multiple matches. The description adds no further meaning to parameters, so it does not compensate for the missing dpop_token description. Given coverage is above 50% but below 80%, the baseline of 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 first sentence clearly states the tool's purpose: 'Which pest stages are modelled for this ground this season.' This is a specific verb (answer/retrieve) with a resource (pest stages for a block). It distinguishes itself from siblings like pest_threshold (likely thresholds) and wildlife_catalog by focusing on pest stages per season, but it does not explicitly name alternatives. The description adds context about data provenance but the core purpose is clear.

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 does not provide explicit when-to-use or when-not-to-use guidance. It explains how data is sourced and interprets some quirks, but never directs the agent to prefer this tool over siblings like pest_threshold or crop_gdd_status. No alternatives are mentioned, nor are conditions for exclusion. The agent must infer usage from the schema and 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?

With no annotations provided, the description carries the burden. It explicitly states that Good Earth does not publish its own entomology thresholds and that authoritative numbers come from the user's extension service, preventing the agent from assuming built-in science. It also notes that geometry is sent once (on block save) rather than on every call, though that detail lives in the schema.

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

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

The description is five sentences, front-loads the core purpose, and uses compact phrasing. Each sentence earns its place — 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?

The description explains the key conceptual model (degree-day accumulation), the three ways to supply pest data, and the warning against inventing degree-day figures. Combined with a rich 'pests' schema and an existing output schema, the agent has enough context to call the tool correctly. Minor gaps like authentication are covered by the 'npub' schema description.

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 75%, and the two required parameters (block, pests) have thorough descriptions, including disambiguation rules and the three input shapes. The tool description itself adds little beyond the schema, so a baseline of 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 opens with a clear statement of what the tool computes — where degree-day stages stand per pest model — and lists the exact returns (heat accumulated, stages crossed, next projected date, and a list of pests to watch). This distinguishes it from sibling tools like crop GDD or disease risk by focusing on user-supplied pest thresholds.

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 trigger (evaluate pest models on a given ground) but does not explicitly contrast with other evaluation tools. However, the detailed 'pests' parameter schema includes three usage shapes and a clear warning, which substantially compensates for the missing when/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 behavioral burden. It discloses that the tool returns ordered steps, that the order matters, and that it is an interview rather than a report generator. However, it does not state whether the call is read-only, what billing or side effects apply, or how the returned workflow should be presented beyond asking one question at a time.

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 purpose is front-loaded in the first line and the operational instruction ('Follow the returned steps in order') comes near the end in its own paragraph. The duplication rationale is somewhat meta and could be trimmed, but the description is still compact and readable.

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 low-complexity tool with an output schema, the description covers the core interaction pattern and the reasoning behind the ordering. It is less complete on invocation conditions: parameter requirements and billing/cost behavior are left to the sparse schema, and no explicit statement about side effects or prerequisites exists.

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 description never discusses `npub` or `dpop_token`, and schema coverage is only 50% (`dpop_token` has no description). It also leaves a conflict: the schema labels npub 'Required' in its description, but the parameter is not in required and has a default empty string, which may mislead an agent.

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 opening line identifies the resource ('season-planning interview') and frames it as 'a workflow to follow,' with follow-up instruction to 'Follow the returned steps in order.' It reads clearly as a distinct plan-the-season workflow, though it does not explicitly distinguish itself among the many sibling tools.

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 explicitly explains when the tool should be used instead of the `plan_the_season` prompt: clients that do not surface prompts can still reach the same interview by calling this tool. No exclusions or sibling alternatives are given, but this is a useful routing/usage clarification.

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 are provided, so the description carries the burden. It discloses meaningful behavior: dates are derived from the block's own frost/soil record rather than a zone map, and the algorithm for start/out/latest is explained. However, it never explicitly states that the call is read-only or what happens on ambiguous matches, leaving some behavioral traits implicit.

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 key sentence is front-loaded and the three questions are formatted as a scannable bullet-like structure. It is longer than strictly necessary, with a few illustrative phrases, but each section earns its place by clarifying hardy vs tender, direct sowing, and succession decisions.

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 rich input schema, the output schema, and the detailed prose, an agent has enough to understand the model and call the tool correctly. The description covers the core calculation semantics and data source; remaining gaps like explicit read-only status and named sibling alternatives are not fatal.

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 75%, so the schema already documents block and crop parameters well. The description adds conceptual context ('requirements are yours', block record rather than zone map) but does not deepen individual parameter semantics beyond what the schema provides, which keeps it at 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?

The description states a specific outcome: it computes when to start seed indoors, when to transplant or direct sow, and the latest date a sowing can still finish. It also distinguishes itself from heat-requirement/can-finish questions, helping an agent tell it apart from related crop tools.

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 explicitly contrasts this tool with 'Heat requirement' and says it answers the practical 'when to start' decision made with a seed packet. It clearly implies when to use this tool, but it does not name a sibling tool such as crop_suitability or gdd_status as the alternative, so it misses the explicit routing of a top score.

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