GardenArena GardenScript

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds the useful domain fact that verification is scoped to published contracts, scenarios and sealed entries, but says nothing about what a failed verification means or any auth/ownership constraints.

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

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

A single front-loaded sentence with no filler; the verb and the object of verification come first. It is efficient, though it leaves obvious room for one more clause of routing or return-value context.

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

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

With an output schema present, return values need not be explained, and the annotations carry the safety profile. However, for a verification tool with a 0%-documented parameter, the description does not state what a positive or negative result implies or when an agent should reach for it over the sibling validators, leaving the definition only minimally 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 only param is named generically as 'digest'. The description compensates partially by specifying it is a SHA-256 digest, which is genuine added meaning, but gives no format, encoding, or length details and says nothing about how the digest relates to the contracts/scenarios it is checked against.

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 (Verify) and resource (SHA-256 digest) plus the domain objects it checks against (contracts, scenarios, sealed entries). It is clear on its own, but it never names or contrasts with the close siblings strategy_validate, validate_gardenscript, or strategy_seal, so an agent must infer which validation path applies.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives among the many sibling validation/seal tools. The agent is left to infer that this is the check-one-digest path versus the broader strategy validation 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds the useful confirmation of 'No run or publication' (no side effects), but discloses nothing about auth requirements, rate limits, or why the challenge is 'fixed'.

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

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

Two tight sentences plus a pointer to the language spec; the core action is front-loaded and no sentence is filler. Nothing is repeated from the schema or annotations.

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

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

An output schema exists, so return values need not be spelled out, and the description adequately frames what the read returns. Minor gap: it does not clarify the relationship to the sibling *_run tools that presumably consume this mission.

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

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

The tool takes zero parameters, so there are no argument semantics to describe; the baseline for a no-parameter tool is 4. Nothing in the description misleads about inputs.

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

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

States a specific verb (Read) and resource (the fixed 365-day bamboo training mission) with enumerated contents (reference, scenario hash, budgets, quotas). It is distinguishable from siblings like bamboo_training_run and bamboo_training_artifact, though the 'Dry Patience' jargon is not self-explanatory without the referenced language doc.

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 run or publication' implies this is a read-only inspection path versus the *_run siblings, and it points to gardenarena://gardenscript/v0.5 for the language. However it never names an alternative tool or states the condition under which an agent should pick this over bamboo_training_explain or get_bamboo_scene.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, covering the safety profile. The description adds useful caveats: strategy sources should not be published automatically, and no run or official ledger write occurs. It does not describe pagination or access/auth requirements for private runs.

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 compact sentences, front-loaded with the core purpose followed by caveats. Minor terse fragments ('No run or official ledger write') but no wasted sentences.

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?

Output schema exists, so return values needn't be explained. The description covers the main caveats but leaves the single param's semantics under-specified given 0% schema coverage, and lacks usage routing among the many 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?

Schema description coverage is 0% for the single run_token parameter, so the description carries some burden. It implies run_token identifies a specific private training run, but adds no format or source detail beyond the pattern already in the schema.

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

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

States a clear verb+resource: reading reproducible request/result hashes for a private training run. This distinguishes it from siblings like bamboo_training_run (executes) and bamboo_training_explain (explains), though it doesn't name those siblings explicitly.

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

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

The description implies usage context (verifying a training run's reproducibility via hashes, downloading the trace via POST export) but provides no explicit when-to-use or when-not-to-use guidance relative to artifact_verify or strategy_validate.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds real value beyond them: the auth requirement (GardenArena run_token vs provider credential) and the guarantee that the returned traces are 'actual Rust decision traces, not a rerun'.

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 compact sentences with the core read purpose front-loaded and the auth caveat placed last. Dense with jargon but no filler; 'both actual Rust decision traces' is slightly awkward phrasing that costs a little clarity.

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 tool with an output schema (so return format needn't be described), the description covers purpose, the optional-parameter behavior, and the credential prerequisite. What remains thin is sibling differentiation and the token format, but nothing critical to correct invocation 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 0%, so the description carries the full burden. It gives partial meaning to both parameters — day (1-365, returns actual traces) and run_token (private GardenArena token, not a provider credential) — but adds no syntax or format detail beyond the range already in the schema, and never explains the token's required 64-char hex pattern.

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 ('Read') and a resource ('training comparison and evidence-linked moments'), and the word 'comparison' hints at a distinct resource from sibling tools like bamboo_training_artifact and bamboo_training_run. However, 'moments' is undefined jargon and the description never explicitly distinguishes itself from those siblings, leaving the agent to infer the boundary.

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

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

It gives a usable prerequisite ('Requires the private GardenArena run_token, not a provider credential') and explains what the optional day parameter yields. But there is no statement of when to choose this over bamboo_training_run or bamboo_training_artifact, so the routing decision is left 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?

The annotations declare readOnlyHint=false, openWorldHint=false, idempotentHint=false, and destructiveHint=false, so the agent knows this is a non-destructive write operation with no external side effects. The description adds valuable context beyond annotations: it specifies temporary local storage, no official submission or publication, no LLM call, shared quotas, and that the run_token must be kept private. This goes beyond what annotations provide, though it doesn't detail error handling or rate-limit specifics.

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 concise sentences that front-load the core action and constraints. It avoids redundancy and packs multiple behavioral details efficiently. Slight improvement possible by integrating parameter guidance, but overall well-structured.

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 need not be described. The description covers behavioral traits and constraints adequately, but it omits any explanation of the required 'source' parameter (0% schema coverage) and doesn't clarify what 'Dry Patience' or 'GardenScript 0.5' entail. For a tool with a mandatory parameter and domain-specific context, more information is needed for correct invocation.

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

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

Schema description coverage is 0%, meaning the single 'source' parameter has no description in the schema. The tool description mentions 'run_token' but does not explain what the 'source' parameter should contain or its format. With a required parameter and no schema documentation, the description fails to compensate for the coverage 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 states a specific action ('consume one bounded private training run') against a named resource ('Dry Patience') with a clear scope. It differentiates from siblings like coop_workshop_run and farm_autopilot_run by specifying it's a bamboo-only training run. However, 'Dry Patience' and 'GardenScript 0.5 bamboo' are domain-specific terms that an agent may not understand without additional context.

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 ('after user agreement') and constraints ('private training run,' 'no official submission'), but it doesn't explicitly state when to use this tool versus alternatives like coop_workshop_run or farm_autopilot_run. An agent can infer it's for training purposes, but the lack of explicit when/when-not guidance leaves 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint false, and openWorldHint false, so the safety profile is covered. The description adds useful behavioral context beyond that: it returns closed JSON commands, covers exact scenario and quotas, and involves no simulation or database write. It does not discuss auth, rate limits, or error behavior, but those are less central for this read-only 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 sentences and front-loads the action and resource. The first sentence packs the content list efficiently, and the final two sentences add disambiguation and behavioral context without waste. 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 read tool that already has full schema coverage, output schema, and annotations, the description is complete enough: it says what is read, what is not done, and how it differs from related competition/workshop tools. No critical gap remains 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?

The tool has zero parameters and the schema description coverage is 100%, with an output schema present. Per the rubric, a zero-parameter tool baselines at 4, and the description does not need to add parameter semantics. No parameter-related information is missing.

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

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

States a specific verb ('Read') and resource ('playable chicken workshop mission'), then enumerates the content domains (breeds, breeding/incubation, production balance, non-lethal predators, closed JSON commands, exact scenario and quotas). It also distinguishes itself from other tools by stating 'No simulation or database write' and contrasting with GardenScript/official competitions, so an agent can identify it apart from the run variant.

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

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

The description gives clear context and exclusions: it is a read-only inspection of mission data, explicitly not a simulation and not a database write, and it is distinct from GardenScript/official competitions. However, it does not explicitly name coop_workshop_run as the execution alternative or give a conditional rule like 'use this before running the mission,' leaving the when-to-use guidance somewhat implicit.

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

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

Annotations already flag non-read-only, non-idempotent, non-open-world behavior. The description goes further by clarifying there is 'No persistent game, official write, provider API or automatic publication' and by explaining the reproducible-state/explanation/export output plus retry-delay and call-budget guidance. That is substantial context beyond the structured 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?

Purpose is front-loaded, followed by parameter meaning, then constraints. Sentences are short and information-dense, though the cluster of negations ('No persistent game, official write, provider API or automatic publication') is slightly terse and could be tightened.

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

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

With an output schema present, return values need not be spelled out, yet the description still summarizes them. For a single-parameter mutation-ish tool with annotations covering the safety profile, the description supplies the format, constraints, and budget guidance an agent needs 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 0%, so the description must carry the load for the single parameter. It does: journal_json is 'the complete closed JSON journal (64 KiB), NOT GardenScript or arbitrary code,' which tells the agent the expected format and the critical exclusion—well beyond the schema's bare type/maxLength.

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: 'Execute one bounded Rust chicken-workshop journal.' An agent can distinguish it from the read counterpart (coop_workshop_get) and from the validation siblings. It stops short of explicitly naming the alternative, but the action is unambiguous.

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

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

'after human agreement' gives a clear precondition, and 'NOT GardenScript or arbitrary code' steers away from the validate_gardenscript family. However, it never states when to prefer this run tool over, say, coop_workshop_get or farm_workshop_run, leaving the selection logic 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?

Annotations say destructiveHint=false but idempotentHint=false, while the description states idempotent retries ARE supported via idempotency key + nonce. This adds substantive behavioral context (nonce returned once, must be retained, not returned again; entry unseated until organizer confirms; write-gated) that annotations do not cover. It does not contradict annotations since the nonce-based retry is a distinct mechanism, though it merits a careful 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?

Short, front-loaded, every sentence carries a distinct fact (return value, nonce lifecycle, retry rule, identity constraint, seating rule, gate). Dense but readable; could group the nonce/retry sentences for flow.

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?

Output schema exists so return values need not be explained, yet 10 undocumented params with 0% coverage leave the parameter space largely opaque; identity_assurance's stated constraint (anonymous or declared) is the only enum-like hint. The nonce and write-gate are covered, but key capability defaults are not, so the definition is only partially complete for a 10-param creation tool.

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

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

Schema description coverage is 0% across 10 params, so the schema does not document them. The description explains only entry_nonce and, by implication, idempotency_key semantics; the other 8 params (arena_id, trial_id, host_claim, model_claim, provider_claim, evaluation_mode, competition_scope, identity_assurance) get no explanation. For a 10-param tool, this is a significant gap, and baseline is set accordingly low but raised by the nonce/key notes.

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?

Clear verb+resource: 'Create a Reality Trial 001 policy entry' specifies exactly what is created. The artifact name is specific enough that it doesn't need sibling differentiation, though it could name the read-side or verification sibling (e.g. artifact_verify) to anchor it further.

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?

Implied usage: 'Write-gated' and the nonce/retry note hint at the workflow, but there is no explicit when-to-use vs when-not-to-use, nor a pointer to which sibling continues the flow (e.g. artifact_verify). The agent can infer the entry-creation step but not the 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?

Richly discloses behavior beyond annotations: deterministic Rust rules, no live LLM, explicit exclusions (no sales, no new animals, no publication, no background daemon), and the fact that it returns a replayable journal with per-action reasons/costs. Annotations only cover readOnly/idempotent/openWorld hints, so this extra context is valuable.

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

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

Front-loaded with the core action and constraints, then behavior, then return shape. Dense but every clause carries information; could be slightly tightened but is well-structured.

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 (simulated multi-day tour with budget and command limits), it covers scope, determinism, exclusions, and return characteristics. The presence of an output schema means it needn't detail the journal structure, so the description is complete for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the semantics of max_days (1–7 simulated days), budget_credits (0–1000 game credits), and the implicit 64-command cap, though journal_json's format/constraints (maxLength 65536) are left to the schema. The description adds real meaning beyond the bare parameter names.

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 (Run) and resource (bounded pantry-oriented farmer tour), plus explicit scope (simulated days, credits, command cap). Distinguishes itself from sibling farm_* tools by naming the exact simulation semantics and 'not a live LLM'.

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?

Implies usage via 'after user agreement' and 'a human chooses whether to import', but doesn't explicitly say when to use this versus siblings like farm_policy_run or farm_compare_run. The gating condition (user agreement) is stated, which is better than nothing but not full 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description reinforces and expands on these by confirming there is no calculation or publication, and by noting the output is 'JSON plan, NOT GardenScript,' which is a meaningful behavioral clue beyond the annotations' safety flags.

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 carry distinct value: what is read, what is explicitly excluded, and what format the result takes. The key information is front-loaded, and there is no redundant filler or repetition of the tool name.

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

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

With zero parameterschers an output schema, the annotations, and a description that specifies the exact source content, boundaries, and output format, the agent has all the contextual information needed to invoke this tool correctly. 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?

The schema has zero parameters no required or optional inputs — so there are no parameter semantics to document. The description still provides useful context about what a caller will receive, and the baseline for a zero-parameter tool is 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 names a concrete verb ('read') and a precise resource ('chapter 2 stewardship-v1: exact teaching farm J95'), then lists exactly what the returned content contains. It also draws clear boundaries ('not the player's private farm', 'No calculation or publication'), which differentiates this from sibling tools that operate on private or dynamic farms.

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 this tool: to inspect a fixed, teaching-oriented campaign snapshot rather than to calculate, publish, or access a player's private farm. It provides clear exclusions and context, though it does not explicitly name a sibling alternative such as farm_campaign_run, so the routing is left partly to inference.

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

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

The description adds substantial behavior beyond the annotations: Rust decides from current state, retains adverse days, reports costs/refusals/meals, and is bounded to ten days and 100 added commands. It also explicitly prohibits persistent save, LLM calls, and background search, consistent with openWorldHint=false, though terms like 'shared workshop quotas' and 'full autonomy' remain under-specified.

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 dense but every sentence carries relevant information, and the purpose is front-loaded. Some later warnings like 'Local meals do not imply full autonomy' are cryptic, but they are not 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 covers the parameter format, run bounds, side-effect boundaries, and the output ('complete export'), so an agent can attempt a call. It relies on domain jargon such as J95-J105, adverse days, and workshop quotas without fully explaining them, but the output schema and domain context mitigate those gaps.

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

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

With 0% schema coverage, the description carries the full burden and succeeds. It defines choices_json as a CLOSED object with fixed mission_id and enumerates all valid values for harvest, egg_reserve, and rotate, which is exactly the semantic content the schema lacks.

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 action, 'Try the fixed J95 to J105 farm chapter,' and names the resource and its closed choices object. However, 'Try' is a weaker verb than 'run' and the description never explicitly contrasts this tool with farm_autopilot_run or farm_campaign_get, so it is clear but not fully differentiated.

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

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

It gives a clear precondition ('after agreeing a finite call budget') and indicates the downstream flow ('human chooses adoption'), plus a list of excluded capabilities. But it never names sibling tools or states when farm_campaign_run should be chosen over farm_autopilot_run or farm_campaign_get.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, so the safety bar is met. The description adds real behavioral context beyond that: the contract is bounded, V4-only, uses the same start/days/budget per branch, and produces no global winner or publication.

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 clause and the three sentences are compact. It is somewhat dense with packed domain terms and the closing 'no persistent write' mildly restates the readOnly annotation, but nothing is padded.

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

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

With an output schema present, return values need not be spelled out, and the description covers scope and constraints for a zero-param read. The remaining gap is that undefined domain tokens (J96, week-after-v1, V4) are left unexplained for an agent lacking that vocabulary.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies; no parameter detail is needed or missing.

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

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

The verb 'Read' plus the resource 'bounded two-policy farm comparison contract' is specific, and the closing 'No paired trial or persistent write' distinguishes it from the sibling farm_compare_run. However, heavy domain jargon (J96 journal, week-after-v1, V4 only) makes the exact payload harder to grasp than the sibling split alone would.

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 routes the agent to farm_policy_get for syntax ('Read the farm policy contract for syntax') and implicitly excludes the run variant ('No paired trial'), which is useful. But it never states the condition under which an agent should prefer this read over farm_compare_run or what prerequisite state must hold.

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

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

Adds materially beyond annotations: it charges two shared workshop quota units, performs no game mutation/persistence/publication/LLM calls, returns both branches plus trace witnesses of first divergence, and deliberately never declares an overall winner. Annotations only cover the generic read/write/idempotency profile, so the quota cost and non-mutation guarantees are genuinely new information.

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

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

Front-loaded with the core action, then constraints, then exclusions. Dense but nearly every clause carries operational meaning; the trailing negatives list is the least efficient part.

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 5-parameter, 0%-coverage tool with an output schema, the description covers behavior, side effects, and scope exclusions well, and it points at the returned export rather than re-describing it. Remaining gap is per-parameter detail and how required vs optional inputs interact.

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 0%, so the description must carry parameter meaning; it clarifies that source_a/source_b are GardenScript farm.v1 policies, journal_json is a complete v4 journal, and budget/days are the 0–1000 ceiling and 1–7 day window. However it omits the 16384/65536 length limits, defaults, and how the call budget maps to the single budget_credits field.

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 — comparing two GardenScript farm.v1 policies from the same v4 journal — and pins the scope tightly (two trials, 1–7 days, identical 0–1000 ceilings). An agent can distinguish it from farm_policy_run and farm_compare_get 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?

Gives clear preconditions: both policies must come from the SAME complete v4 journal and a finite call budget must be agreed first, with two trials of matching duration and credit ceilings. It also rules out adjacent features (no legacy future-veto helper, no v5 weather, no official ranking), though it never names the sibling tools it substitutes for.

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?

Goes beyond the annotations (readOnlyHint=false, destructiveHint=false) by disclosing quota cost ('Consumes one agreed calculation call') and side-effect bounds ('No automatic care, publication or persistent write; human chooses whether to import'). This clarifies that despite readOnlyHint=false there is no persistent mutation, adding real value beyond structured fields.

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 action and constraints are front-loaded into a compact, single-paragraph description with the quota and side-effect limits at the end. A few phrases ('unchanged Rust result', 'agreed calculation') are jargon-heavy but the sizing is appropriate.

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

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

An output schema exists, so return values need not be enumerated, yet the description still names them. For a tool that consumes a shared calculation call, the definition covers behavior, quota cost, and side-effect scope adequately; only parameter format detail is thin.

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 0%, so the description must compensate. It restates max_days and its 1–21 range (already in the schema) and gives useful content hints for care_json ('ration, access, ventilation, incubator'), but does not explain the journal_json/care_json structure or required format.

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: 'Advance a farm journal to the next detected important moment,' which an agent can act on. It is reasonably distinct from the many *_run and *_get siblings, but it never explicitly contrasts itself with alternatives, so it stops short of 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?

Provides implied usage ('checked daily for at most max_days', 'human chooses whether to import') but never states when to use this versus siblings like farm_autopilot_run or farm_compare_run, nor any preconditions or when-not conditions. Context is inferable but not spelled out.

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

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

Annotations cover safety (readOnly, idempotent, non-destructive). The description adds value beyond that by enumerating what is returned (six channels, 29 sensors, presets, limits) and explicitly disclosing negative behaviors: no run, no persistent write, no LLM call.

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

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

Two dense sentences, front-loaded with what the tool reads, then constraints. Efficient, though slightly information-packed in the first sentence.

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

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

An output schema exists so return values need not be explained, yet the description still summarizes contents. Combined with explicit exclusions (no run/write/LLM), an agent has enough 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?

Zero parameters, so baseline is 4. The description correctly implies a no-argument retrieval tool, consistent with the empty schema.

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

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

States a specific verb (Read) and resource (GardenScript 0.6 farm.v1 policy) with concrete scope: six decision channels, 29 sensors, exact intention expansion. Distinguishes itself from siblings like farm_policy_run and farm_policy_validate by explicitly stating it performs no run and no write.

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

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

Explicitly directs 'Read before writing a farm policy,' giving clear usage context and sequencing relative to farm_policy_run. Does not name specific alternatives or exclusions, but the read-before-write guidance is actionable.

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

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

Annotations already say readOnlyHint=false and idempotentHint=false, but the description adds substantial behavioral detail beyond them: shortages pause after commitment, there is no future weather access, no LLM calls, no publication, no persistent game or daemon, and the human explicitly imports the result. It also previews the return structure, including export, source, witnesses, accepted/rejected commands, and costs.

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 action and key constraints, but it is dense and uses fragmented clauses that make it harder to scan than necessary. Much of the text earns its place by adding behavioral constraints, yet some phrasing could be clearer and more organized.

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?

It provides rich operational constraints and an output preview, and an output schema exists, so return values need not be fully explained. However, with 0% schema parameter coverage and no direct sibling guidance, an agent still lacks enough context to confidently set source, max_days, and budget_credits.

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 for four undocumented parameters. It clarifies that journal_json must be a COMPLETE v4/v5 journal and that budget_credits maps to a finite call budget, but it does not define source, max_days, or the exact constraints/meanings of the 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?

States a specific verb (run) and resource (GardenScript 0.6 farm.v1 policy from a complete v4/v5 journal), so the agent knows what the tool does. It also rules out the official competition and the legacy precognitive helper, though it does not directly differentiate from farm_policy_validate or farm_autopilot_run.

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

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

Gives clear usage context: run after user agreement, within a finite call budget, with no future weather archive access and no cancellation of bad days. It also names exclusions such as not being an official competition or legacy safety helper, but stops short of explicitly naming the sibling to use instead for validation or autopilot scenarios.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds substantive behavioral context beyond that: 'Local Rust only' (implementation/isolation), 'Shared workshop quota' (a resource constraint/rate consideration), and explicitly negates side effects ('no run, persistence or publication'). It even notes outputs (line diagnostics, exact hashes).

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

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

Two tight sentences, front-loaded with the action and input constraint, followed by environment/behavioral facts. No filler.

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

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

Given a single param, rich annotations, and an existing output schema, the description covers purpose, input constraint, environment, and side-effect scope adequately. Minor gap: no explicit routing to sibling validators for other dialects.

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?

Only one parameter, and schema description coverage is 0%, so the description must compensate — it does, stating the value is a 'closed GardenScript 0.6 farm.v1 source, maximum 16 KiB,' which clarifies both the accepted format and the size limit (matching maxLength 16384).

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

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

States a specific verb+resource: 'Validate a closed GardenScript 0.6 farm.v1 source.' Distinguishes from siblings like validate_gardenscript and strategy_validate by naming the exact grammar version (GardenScript 0.6) and dialect (farm.v1), so an agent can tell which validator to call.

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 this (checking a farm.v1 source before running/publishing) via the contrast with farm_policy_run and 'no run, persistence or publication,' which is a soft exclusion. But it never explicitly says 'use this before X' or names validate_gardenscript/strategy_validate as alternatives for other dialects.

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

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

Annotations already declare readOnly, idempotent, non-destructive and openWorld, so the safety profile is covered. The description adds genuinely new behavioral context beyond that: data is cached, it returns a frozen snapshot with station distance/dates/licences, forecasts are not observations, and no paid API/LLM call/publication occurs.

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

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

Front-loads the core action and stays dense and earn-your-place, with only mild redundancy in the trailing negative list (no paid API, LLM call, publication). Multi-sentence but well organized for a tool with this much behavioral nuance.

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

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

With an output schema present, return-value explanation is optional yet the description still notes the snapshot contents, and the annotations plus description together fully characterize a read-only cached fetch. The main remaining gap is the absence of explicit guidance against sibling farm_weather_search.

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 carry the param burden, and it does add meaning: commune_code is a French INSEE code, and start_date/station_id retain an existing game's station/start when refreshing. It doesn't give format details (date syntax, station id format) for the optional fields, keeping it short of a 5.

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 (Read) and resource (cached MET Norway forecasts + Météo-France station archive) scoped to a French commune INSEE code, so the agent knows exactly what it fetches. It does not, however, differentiate itself from the sibling farm_weather_search, so an agent must guess which one to pick.

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 explains the refresh case for the optional start_date/station_id and notes that applying the result needs a separate closed weather_station command, which is useful context. But it never states when to use this tool versus farm_weather_search or other siblings, leaving the routing decision implicit.

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

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

Annotations already declare read-only, idempotent, non-destructive, and open-world. The description adds genuinely new behavioral context beyond them: public administrative data, cached and bounded results, and explicit non-behaviors (no IP geolocation, no precise address, no game mutation, no LLM call).

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

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

Front-loaded with the core action in the first sentence, followed by supporting data/boundary notes. Tight and free of filler, though the trailing negative list is slightly dense.

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

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

An output schema exists so return values need not be described, and annotations carry the safety profile. The description supplies data provenance, caching/bounding, and privacy boundaries, leaving only minor gaps like result limits or pagination behavior.

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

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

Schema description coverage is 0% for the single 'query' parameter, so the description must compensate. It does explain that query accepts a name or a postcode, which is real added meaning, but gives no format details, casing, or matching behavior for either input style.

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 (Find), resource (French metropolitan communes), and the lookup keys (name or postcode), framed for opt-in farm weather. It is clearly distinguishable from a lookup tool, though it never names the sibling farm_weather_get it presumably precedes.

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

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

The phrase 'for opt-in farm weather' implies this is the search step preceding farm_weather_get, but there is no explicit when-to-use, no exclusions, and no mention of the actual sibling tool. Usage is only inferable.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds useful framing that this is an 'Educational simulation' with no run or official write, but supplies no further behavioral detail beyond what the annotations provide.

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

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

Two sentences, front-loaded with the action verb 'Read', with no filler. Dense jargon slightly reduces readability but nothing is wasted.

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

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

An output schema exists, so return values need no explanation, and annotations carry the safety profile. The description identifies what is read and that no writes occur, leaving it adequately complete for a zero-parameter read 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?

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing for the description to clarify on the parameter side.

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 clear verb ('Read') and enumerates what is returned: the whole-farm mission, shared resources, JSON actions and the farmer task contract, which identifies the farm_workshop resource. It implicitly contrasts with the run counterpart via 'no run', though the jargon ('closed JSON actions', 'farmer task contract') is less self-explanatory than ideal.

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 run or official write' gives negative guidance that implies the run-oriented sibling (farm_workshop_run) is the alternative, but the alternative is never named and no positive when-to-use condition is stated. Usage is 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?

Annotations already declare not read-only, not idempotent, not destructive, and closed-world. The description goes beyond them by enumerating non-effects (no autonomous daemon, no publication, no LLM call, no persistent game) and the call-budget bound, which genuinely informs the agent about side-effect scope.

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

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

Front-loaded with the action, then the precondition, input constraint, return shape, and negative guarantees. Each sentence earns its place with no filler.

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

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

An output schema exists, so return values need not be spelled out, and the description still notes the key outputs. Combined with the precondition and input format, it is nearly complete, though the 'agreed call budget' concept is asserted without saying how it is determined.

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 0% for the single parameter, so the description must compensate; it does, specifying that journal_json is complete closed JSON rather than GardenScript and capped at 64 KiB. That tells the agent the accepted format and a failure mode the bare schema does not.

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 (Execute) and resource (one bounded whole-farm Rust journal), with a scope qualifier ('bounded'). An agent can distinguish it from farm_workshop_get (read) and validate_gardenscript, though siblings like farm_policy_run are not explicitly contrasted.

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 precondition: run only 'after human agreement, within the agreed call budget,' which distinguishes it from read-only siblings. It stops short of naming which alternative to use when agreement is absent or the budget is exhausted.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world. The description adds real behavioral context beyond them: it enumerates included fields (sensors, entrant, SHA-256 provenance) and disclaims side effects ('No database access, simulation launch, external network or LLM call').

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?

Core purpose and the parameter note are front-loaded, and each sentence is short. A few trailing negations ('Koi are decorative and unranked') feel defensive but are arguably needed to set expectations for a synthetic exhibition feed.

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

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

An output schema exists, so return values need not be explained, and the annotations cover the safety profile. Between the description's payload summary and exclusions, an agent has enough to invoke it correctly, though the relationship to sibling bamboo tools remains unstated.

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

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

With 0% schema description coverage, the description carries the burden and does add meaning: 'day' is interpreted as day-of-year in the 1-365 range, with the default resolving to the current UTC day of year. The range itself duplicates the schema, but the semantic interpretation of the parameter is genuinely added.

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 ('Read one day ... of the published Rust bamboo replay used by the 3D scene') and clarifies the payload includes sensors, entrant and SHA-256 provenance. It is clear what the tool does, though it does not explicitly name which sibling (e.g. bamboo_training_artifact or bamboo_challenge_get) it is distinct from.

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

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

Provides scope exclusions ('not an observation, strategy evaluation or hydraulic forecast' and 'Synthetic exhibition only'), which narrows when it applies. However, it never names an alternative sibling or states the condition that would route an agent to a different bamboo/farm tool, leaving usage largely 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?

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered; the description still adds a real trait beyond them by noting no LLM call is made (cost/latency implication). It does not describe error behavior for an unknown slug, so it stops short of a 5.

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

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

Two tight sentences with the resource and key first and the non-obvious LLM-cost remark second; 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?

An output schema exists so return values needn't be explained, and the description still enumerates the returned facets. For a single-parameter, read-only, closed-world lookup it is nearly complete, missing only slug format or missing-arena behavior.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden; it does only minimally by saying lookup is 'by slug', establishing that the identifier is a slug. It gives no format, examples, or slug-source guidance, leaving the lone required parameter thin.

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 (Read) and resource (one arena) and enumerates exactly what is retrieved: ruleset, scenario, capabilities, limits, status, keyed by slug. The 'one ... by slug' phrasing clearly separates it from list_garden_arenas.

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 implied rather than stated: 'This performs no LLM call' hints that this is the cheap inspection step before the *_run tools, but no alternative or when-not condition is named explicitly. An agent must infer that list_garden_arenas is for enumeration and this is for a single lookup.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and non-open-world behavior. The description adds useful context beyond annotations by clarifying that no simulation or LLM call is performed, which prevents agents from expecting costly side effects.

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

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

Two short sentences, front-loaded with the core purpose and an immediate clarifying constraint. Every sentence earns its place with no filler.

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

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

For a simple single-parameter read tool with an output schema and rich annotations, the description is nearly complete. The only notable gap is the lack of any explanation of the arena_slug parameter.

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 one parameter (arena_slug) with 0% description coverage, and the tool description does not explain its meaning or expected format. Because schema coverage is low, the description should compensate, but it does not.

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

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

The description gives a specific verb and resource: 'Read the sealed results for a GardenScript arena.' It distinguishes the action from simulation or generation, though it does not explicitly contrast with siblings like get_garden_arena or submit_garden_strategy.

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 implies the tool is for retrieving already-sealed results rather than running anything, reinforced by 'Performs no simulation or LLM call.' However, it does not state prerequisites (e.g., that sealing must have occurred) or name alternative tools for other stages.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=false, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds the useful 'no LLM call' operational context, but says nothing about pagination or result ordering beyond what annotations provide.

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

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

Two short, front-loaded sentences with zero filler. The core purpose comes first and the behavioral note second.

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

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

An output schema exists, so return values need not be explained. However, with three undocumented parameters (0% coverage) and no usage routing among many siblings, the definition is minimally adequate rather than 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%: limit, offset and status have no descriptions in either schema or description. A listing tool with pagination and a filter parameter would benefit from explaining status values and paging behavior, and the description adds none of it.

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

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

States a clear verb+resource: 'List GardenScript arenas.' It distinguishes from the singular sibling get_garden_arena by the plural 'List', but the description never explicitly names that alternative, so sibling differentiation is only implied.

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

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

No guidance on when to use this list tool versus get_garden_arena or get_garden_results. The 'local, read-only, no LLM call' note hints at cost-saving usage but never states a condition for selecting this tool 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?

Annotations only say readOnlyHint=false, idempotentHint=false, destructiveHint=false. The description adds real behavioral context beyond that: a private credential is required, the call deliberately does not confer sealing authority, and a human must drive the resulting page ('never operate that page for them'). Only failure modes and repeat-call behavior are unaddressed.

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 action and its return value, followed by the auth requirement and the safety constraints. Nothing is padded or repeated.

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

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

An output schema exists, so return values need not be elaborated further, and the nonce, authority boundary, and human-in-the-loop requirement are all stated. The only gap is the undocumented entry_id, which matters little for correct invocation.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It characterizes entry_nonce as 'private' and required, which adds useful sensitivity context, but entry_id is never explained. Minimal but adequate compensation.

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 ('prepare') and resource ('review') plus the concrete artifact returned ('confirmation_url'), and negates the sibling strategy_seal with 'Does not grant authority to seal'. The distinction from strategy_seal/strategy_validate is implied rather than explicitly named, but an agent can still separate 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?

Gives clear prerequisites and constraints: requires the private entry_nonce, and the organizer must complete the step in their own web session. It stops short of explicitly saying 'call this before strategy_seal' or naming the alternative, but the context 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?

Annotations already declare readOnly, idempotent, non-destructive, so the safety profile is covered; the description goes further by disclosing the error path (human_confirmation_required for pending entries) and warning that legacy receipt/handle arguments are ignored and are never approval credentials. That adds real behavioral context beyond structured fields, though it does not describe idempotency or re-read semantics explicitly.

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

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

Three tight sentences with no filler; the core identity ('read acknowledgment, never creates') is front-loaded and the routing/legacy-argument caveats follow in priority order.

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

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

With an output schema present, return values need no prose, and the description covers the critical behavioral facts: this is a read, it cannot seal, and the failure mode for unconfirmed entries. The remaining gap is guidance on where entry_id/entry_nonce come from in the prepare-then-seal flow.

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% across four parameters, so the description must carry the load. It only clarifies the two optional legacy parameters (confirmation_handle, validation_receipt_id), stating they are ignored and not credentials, while the two required parameters entry_id and entry_nonce receive no explanation of source, format, or expected provenance.

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 ('Read acknowledgment of an already human-confirmed seal') and immediately draws the boundary against its closest sibling, strategy_prepare_seal, by stating it can NEVER create a seal. An agent can distinguish the read-side seal lookup from the preparation tool without opening either schema.

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

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

It gives an explicit when-not ('pending entries return human_confirmation_required') and routes the agent to the correct alternative action ('Give the preparation's confirmation_url to the organizer instead'). This is exactly the kind of conditional branch an agent needs to avoid mis-invoking a read tool as a write.

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

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

Annotations declare non-read-only, non-idempotent, non-destructive, so the mutation profile is covered. Beyond that, the description adds two meaningful facts: it requires the private entry_nonce and it consumes the entry's validation budget. It still doesn't say what a failed compile leaves behind, so not a 5.

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

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

Three tight sentences, the core action front-loaded, each clause carrying distinct information (what it does, the nonce requirement, the budget cost). 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?

An output schema exists, so return values need not be documented here. Given that, the description adequately covers the action, the prerequisite credential, and the cost. The unexplained 'source' argument and absent failure behavior are the only remaining gaps.

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 carry the load. It clarifies entry_nonce (private, required) and entry_id (existing entry), which is genuine added meaning, but leaves the 'source' parameter entirely unexplained, so partial compensation only.

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 ('Compile GardenScript') plus scope ('for an existing entry without running the official scenario'), which clearly separates it from validate_gardenscript and submit_garden_strategy. It stops short of naming those siblings explicitly, so 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?

Implies the usage context (an existing entry you don't want to run through the official scenario) and warns that it consumes the validation budget, which is a real cost signal. However, it never names the alternative tools (validate_gardenscript, strategy_seal) or states when-not to use it.

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

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

With annotations already declaring the safety profile (non-read-only, closed-world, not idempotent, not destructive), the description adds real value: re-validation by the local Rust compiler, a disabled-by-default state, and the strong auth note that operator identity comes only from the server environment and never a model token. These are non-obvious behavioral facts an agent needs.

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

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

Three compact sentences, front-loaded with the core action and followed by validation and identity caveats. No wasted padding, though the identity sentence is slightly compressed.

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

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

An output schema exists so return values need not be described, and the safety/auth context is covered. But for a mutation tool with 8 undocumented parameters and no idempotency guidance (annotations say not idempotent, so duplicate-submission behavior matters), the definition leaves the agent under-informed about how to call it.

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

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

Schema description coverage is 0% across 8 parameters, and the description documents none of them. It implies 'source' holds GardenScript and that the target is an arena, but arena_slug, entrant_name, and the five provenance fields (model_name, model_version, prompt_sha256, transcript_sha256, model_provider) are entirely unexplained.

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 (submit) and resource (externally generated GardenScript to an arena), so the agent knows it is a write/registration action. It does not explicitly differentiate from siblings like validate_gardenscript or strategy_seal, which handle the related validate/seal phases.

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 'Disabled by default' note provides one important precondition for invocation, and 'externally generated' hints at a context. However, it never states when to use this versus validate_gardenscript/strategy_validate, nor does it describe what happens on a successful submission, leaving usage largely inferred.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world behavior, so the safety profile is covered. The description adds genuinely non-annotated context: no LLM call (deterministic) and no persistence ('stores nothing'), plus the untrusted-input framing. It does not, however, say what a failure looks like or whether compilation has side effects on disk.

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

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

Two short sentences, front-loaded with the core action and followed by the two constraints that matter most. No filler or restatement of the name.

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

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

An output schema exists, so return-value explanation is unnecessary, and the description covers the action, safety posture and determinism. It is slightly thin on the input semantics and on what the validation result communicates, but nothing critical for invocation 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 0% – the single 'source' parameter has no description in the schema. The description only calls it 'an untrusted GardenScript source', leaving format (inline text vs. path), size limits, and syntax expectations unstated, so it does not compensate for the coverage gap. One parameter keeps the baseline from being lower.

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

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

Specific verb pair (validate/compile) plus a specific resource (GardenScript source) and an implementation detail (local Rust compiler). It does not explicitly name a sibling, and several validate-flavored tools exist (strategy_validate, farm_policy_validate, artifact_verify), but the 'GardenScript' resource qualifier makes it distinguishable.

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 'no LLM call' clause implicitly signals this is the deterministic/local validation path, which is useful context for choosing it over LLM-backed siblings. However, there is no explicit when-to-use, when-not-to-use, or named alternative guidance.

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