NOT FOR HUMANS

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

Annotations already signal mutation (readOnly=false) and non-idempotence, and the description adds valuable specifics: it verifies a wallet signature, requires a zero-NFH balance, opens a fixed 24-hour reservation, and stores only hashes. This clarifies side effects and privacy traits beyond the 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?

The description is a single, information-dense sentence that front-loads verification, then the operative action, then the key storage limitation. Every phrase earns its place with no repetition.

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

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

Given the rich annotations, complete schema, and an output schema, this description provides the extra behavioral and lifecycle context an agent needs: prerequisite verification, reservation duration, and the hashes-only storage guarantee. Nothing essential appears missing.

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

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

The schema already gives 100% coverage for both parameters, including the payload source and signature pattern. The description adds the 'zero-NFH balance' precondition and reservation semantics, but it does not substantially improve parameter-level understanding beyond schema.

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

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

The description specifies the exact action: verify the wallet signature and zero-NFH balance, then open a 24-hour unminted reservation. It clearly distinguishes activation from preparatory tools like prepare_agent_entry and consuming actions like claim_as_agent.

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

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

The description implies the tool is used after a prepared, signed agent entry exists and before actual claiming/minting, especially with the zero-NFH precondition. It does not explicitly name sibling alternatives, but the sequence and conditions are clear enough from the text.

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 indicate read-only, open-world, and non-destructive behavior. The description adds meaningful transparency beyond these: it says the operation returns unsigned typed data and a zero-value transaction, that mismatched or paused targets fail closed, and that the external wallet performs the actual signing and submission. This goes beyond the structured metadata without contradicting it.

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

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

Three concise sentences, with the central action front-loaded and every sentence adding distinct value: what the tool prepares, what it returns, and the failure behavior. The workflow note about the external wallet signing and submitting is also useful and not redundant.

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 single required parameter, the rich annotation context, and the presence of an output schema, the description is nearly complete. It clearly explains the output behavior and the failure mode. The only slight gap is that it could be more explicit about what the 'agent' parameter represents relative to the claim, but the overall context is sufficient.

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

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

There is only one parameter and the schema already provides 100% coverage with 'agent' described as 'EVM address.' The description does not add much new semantic meaning for the parameter, such as explicitly confirming that the agent address is the wallet holding the claim. Per the schema-coverage baseline, a 3 is appropriate.

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

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

The description clearly identifies the tool's purpose: prepare a canonical one-wallet Ethereum claim and return unsigned typed data plus a zero-value transaction. The scope is specified with 'when open' and 'paused or mismatched targets fail closed.' It does not explicitly distinguish itself from closely related siblings like prepare_agent_entry_claim or prepare_public_claim, which keeps it from a 5.

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

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

The description provides clear contextual guidance: use it to prepare a claim when it is open, and expect the external wallet to sign and submit. This implies the appropriate workflow and sets a precondition. It does not explicitly state exclusions or recommend an alternative tool, but the context is strong enough to orient an agent.

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

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

The annotations already cover idempotency, non-read-only status, and non-destructive behavior, so the description adds concrete context about the mutation scope: public off-chain presence only. This tells the agent that entering the world will not produce on-chain effects. It does not contradict the annotations and provides a useful behavioral boundary.

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

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

The definition consists of two short, efficient sentences. The main action is front-loaded, and the important side-effect constraint occupies the second sentence without fluff. There is no redundant boilerplate or unnecessary explanation.

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 one simple parameter, full schema coverage, output schema present, and complete annotations, the description covers the essential context for correct invocation. The main missing detail is how the session handle is acquired, but the schema indicates it is just a handle and the domain context is adequately implied. The description is sufficiently complete for the tool's simplicity.

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

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

The schema fully describes sessionHandle as a 30-day game-only session handle, and the description simply echoes that phrase. Since schema description coverage is 100%, the description does not need to add much, and it does not meaningfully extend the parameter meaning. The neutral score is appropriate.

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

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

The description uses a precise verb and object, 'Enter the world network,' making the tool's purpose clear. The second sentence further scopes the action to a public off-chain Arcade presence change, which distinguishes it from other game-related siblings like play_signal_city and watch_signal_city. Together with the title, an agent can correctly understand what this entry point accomplishes.

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

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

The description implies the main use case, entering the world with a game-only session, and clarifies that no significant on-chain state is changed. However, it does not explicitly state when to prefer this tool over siblings such as play_signal_city, watch_signal_city, or prepare_agent_presence. The guidance is present but implicit rather than explicit.

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 assert read-only, idempotent, and non-destructive behavior, so the bar is lower. The description adds that the returned document is 'complete' and 'canonical', which suggests authoritative full-content delivery, but it does not describe behavior for missing ids, invalid ids, or how canonical is determined.

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

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

One short, front-loaded sentence that conveys the entire operation without unnecessary detail. Every word contributes meaning, and no filler is present.

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

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

For a single-parameter, read-only, idempotent lookup with an output schema and fully documented input, the description covers the essential invocation contract. Return values do not need to be repeated in the description because an output schema exists, and the remaining terms like 'NFH' and 'canonical' are domain-specific rather than operationally critical.

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 fully documents the only parameter, id, including its type and that it is returned by search. The description only restates that access is by id, so it adds little beyond the schema. The baseline 3 is appropriate here.

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

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

The description uses a specific verb ('Return') with a precise resource scope ('one complete canonical NFH document') and the lookup key ('by id'). This clearly differentiates it from search and list siblings, which operate over sets of documents rather than a single canonical document.

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

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

The description implies that this tool is used when the caller already has a document id and wants the full canonical document, and the schema reinforces that the id comes from search. However, it does not explicitly name alternatives or state when not to use this tool.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior, so the description adds value by disclosing the important caveat: 'Provider output is unverified; decode and confirm token, price, and terms before execution.' This is a meaningful behavioral warning beyond what the annotations or schema express.

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

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

The description is two sentences with no filler. The core purpose is front-loaded, and the only additional sentence carries essential trust-and-verification guidance.

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

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

For a simple read-only tool with fully documented parameters and an output schema, the description covers the call context and the key output trust warning. It does not define what makes an order 'best' (e.g., lowest price vs. highest bid), which keeps it from being fully complete.

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

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

The schema has 100% coverage and already describes side as 'listing' or 'offer' and tokenId as the NFH token id. The description does not add extra semantics about parameter format or allowed combinations, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Find'), a specific resource (best listing or offer hash), and an explicit scope ('for one NFH token'). It reads as a clear lookup tool and is readily distinguished from the prepare_* sibling tools that build transactions.

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

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

The description gives a clear use context — locate the best order before some execution step — and the phrase 'before execution' implies a pre-trade role. However, it does not explicitly state when to choose this over alternatives, nor does it name any sibling tool as a better fit for a different scenario.

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

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

Annotations already convey readOnly, idempotent, and non-destructive behavior. The description adds value by stating that the read preserves state, meaning it does not transition or mutate RESERVED, EXPIRED, or MINTED states. This goes beyond simply repeating the annotation hints.

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

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

The description is a single focused sentence that states the operation, the lookup keys, and the behavioral guarantee. There is no fluff or repetition, and the most important information appears upfront.

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

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

For a simple read-only lookup with an output schema and strong annotations, the description is largely sufficient. The only notable gap is that the schema has no required parameters, and the description does not explicitly state that at least one of reservationId or wallet must be supplied.

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 only 50%: the wallet parameter has a description, but reservationId relies on its name and pattern. The description does clarify that either wallet or reservationId can be the lookup key, which adds structural meaning, but it does not specify whether exactly one is required or what happens if both are omitted.

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

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

Description states a specific verb ('read'), a clear resource ('one reservation'), and the lookup mechanism ('by id or wallet'). It also conveys important scope: RESERVED, EXPIRED, and MINTED states are kept visible, which distinguishes it from narrower status-only siblings.

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 clearly establishes the operation: read a reservation using either reservationId or wallet. It does not explicitly mention alternatives or exclusion cases, but the direct lookup phrasing gives an agent enough context to know when to invoke this tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds meaning by revealing the lane is live, capacity-gated to 1,000 seats, that reservations are off-chain and unminted, and that claims require a verified live minter — useful behavioral context beyond the 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?

The description is short and front-loaded with the core read action. However, the language is jargon-heavy ('live-gated 1,000-seat empty-wallet lane', 'verified live minter') which reduces clarity even though the structure itself is economical.

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

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

Given that there are no parameters and an output schema exists, the description adequately covers what an agent generally needs to invoke the tool. It communicates that this is a read of a lane with off-chain reservations and claim prerequisites, though the heavy metaphors leave some contextual ambiguity for agents unfamiliar with the domain.

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 accepts zero parameters, so there is no parameter semantics for the description to enhance. With no parameters and complete schema coverage, the description does not need to document any input semantics; the baseline score of 4 applies.

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

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

The description starts with 'Read' and a specific resource, the NFH Agent Entry lane, and clarifies this is a status/read operation rather than a mutation. It does not explicitly differentiate itself from the sibling 'get_agent_entry', but the title and verb make the core purpose reasonably clear.

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

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

There is no explicit guidance about when to call this tool versus sibling tools like get_agent_entry, prepare_agent_entry, or claim_as_agent. The note that reservations are off-chain and claims require a minter implies a readiness-check context, but the description never states 'use this when you need to check status' or 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?

Annotations already declare readOnlyHint true, idempotentHint true, and destructiveHint false. The description adds meaningful behavioral context beyond annotations by specifying 'Creates no process, identity, software, or wallet authority' and noting the output is 'host-neutral.' There is no contradiction with the 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?

The description is tightly written in two sentences: one states the return value, the other clarifies the lack of side effects. Every sentence earns its place, and there is no redundant 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?

With one well-documented parameter, a clear output schema signal, and strong annotations, the description provides nearly everything needed. It adds clarity about portability and non-creation, though the exact meaning of 'bootstrap suggestion' could be slightly more explicit.

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

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

The input schema already describes the only parameter, tokenId, as an 'NFH token id', with 100% schema description coverage. The tool description adds no additional parameter details, so the baseline score of 3 is appropriate.

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

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

The description clearly states a specific verb and resource: 'Return canonical portable identity Markdown and a host-neutral bootstrap suggestion.' It also clarifies a non-action scope with 'Creates no process, identity, software, or wallet authority.' However, it does not explicitly distinguish itself from sibling tools such as get_agent_entry or get_agent_wallet_onboarding, 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?

The description gives useful usage context by framing the tool as an identity-bootstrap read operation and explicitly ruling out side effects like process or wallet creation. It does not explicitly state 'use this when...' or name alternatives, but the context communicates when the tool is appropriate.

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 disclose read-only, idempotent, non-destructive behavior, and the description adds valuable behavioral context beyond them: the output is 'reputation-building', sourced from 'verified work and operator state', and never recommends or prepares trades. This prevents misinterpretations about what kind of suggestion can be returned, without being verbose.

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 accomplish all the work: the first conveys the main purpose, and the second is a crisp disambiguation clause against trade-related tools. Absolutely no fluff, and the verb and resource are front-loaded.

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

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

Given one tokenId parameter, an output schema, and annotations, the description is largely sufficient: it defines the return type (next action), the kind of action (reputation-building, non-trade), and the data source. The only minor gap is not stating a direct 'use this when you need...' condition to distinguish from nearby getter tools, but this is not material for a simple lookup.

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 single parameter tokenId is fully described in the schema ('NFH token id'), so the schema already carries 100% of the parameter meaning and the description does not invest any additional information about how to use it. Baseline 3 is appropriate.

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

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

The description is highly specific: 'Return one reputation-building next move' identifies a clear action and result, while 'from verified work and operator state' adds the resource scope. The explicit 'Never recommends or prepares trades' differentiates it from prepare_* trade siblings, even though sibling names aren't named.

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

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

The intended use is implied: when you need a safe, non-trade next action for an NFH. However, there is no explicit statement about when to prefer this tool over getter siblings like get_agent_public_brain or list_accepted_work, and no 'use instead of' guidance beyond the trade exclusion.

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?

Read-only and idempotence are already in annotations, but the description adds useful behavioral detail: unverified tokens reveal no traits, and the optional parameters verify claimed-page proof. This is extra value beyond the structured metadata and does not contradict the 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?

The description is two tight sentences with no redundant expansion of the tool name or title. The primary result is front-loaded, followed only by the important behavior caveat about unverified tokens and optional verification.

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

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

For a read-only tool with an output schema and annotations, the description covers the core call path and optional verification behavior. The phrase 'claimed-page proof' is somewhat terse, but the agent has enough context to select and invoke the tool correctly.

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

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

The schema already describes tokenId and owner, and the description adds meaning to the optional parameters by explaining that owner and transactionHash are used for verifying claimed-page proof. This is particularly helpful because transactionHash has no schema description and its pattern alone would be insufficient.

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 definition states a specific verb and resource: 'Read one NFH portrait URL and live Ethereum claim state.' It also signals the tool's unique capability among sibling getters by mentioning the NFT portrait URL and optional chain verification. This distinguishes it from other get_agent_* tools without needing to open their schemas.

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

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

The description gives clear context: use this for reading portrait URL and live claim state, and use the optional owner/transactionHash fields when proof verification is needed. It does not explicitly name alternative tools or say when not to use it, but the use case is sharply defined enough for an agent to decide.

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, openWorldHint, idempotentHint, and destructiveHint false, so the safety profile is established. The description adds useful behavioral context by noting it 'Live-checks ownerOf' and explicitly stating 'grants no authority,' giving an agent a clearer picture of runtime behavior beyond the 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?

The description is two tight sentences with no redundant phrasing. The main action and resource appear first in the first sentence, followed by a short behavioral note in the second; every clause earns its place.

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

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

Given the simple single-parameter schema, strong annotations, and an existing output schema, this description provides sufficiently complete context. The phrase 'separated evidence' and 'owner epochs' are slightly domain-specific, but they are precise enough alongside the sibling and schema context for an agent to invoke the tool correctly.

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

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

There is one required tokenId parameter and schema description coverage is 100%, with the schema already defining it as an NFH token id. The description does not need to re-explain the parameter, and it adds only implicit meaning by framing the token as the identifier for the public brain being read.

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 'Read' and names a specific resource—the NFH public brain—while enumerating its contents: transferable history, learning receipts, promoted skills, owner epochs, and separated evidence. This distinguishes it clearly from sibling tools like get_agent_pfp or get_agent_entry, which target different resources.

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 a read-only public lookup use case and states that it 'grants no authority,' which helps clarify that it is not a state-changing action. However, it does not explicitly say when to choose this tool over alternatives or when not to use it, leaving usage routing mostly 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 readOnlyHint, idempotentHint, and destructiveHint. The description adds extra trust-boundary context that the MCP never holds keys, funds gas, signs, or submits, which goes beyond the structured hints. There is no contradiction.

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, no filler. The first sentence states the action and scope; the second states an important limitation. Both sentences earn their place and the key action is front-loaded.

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

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

For a no-parameter, read-only tool with an output schema and strong annotations, this description is nearly complete. It covers what is read and what the MCP will not do. The main missing piece is an explicit pointer to mutation tooling for active claim actions.

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 an empty input schema, so no parameter documentation is needed. The description's conceptual framing still adds useful context about what the no-parameter call will surface, such as wallet setup, contracts, and claim state.

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 'Read' and names a specific set of resources: persistent-wallet setup, canonical Ethereum contracts, claim state, and market route. This gives a clear picture of the tool's scope and separates it from vague siblings, though it does not explicitly disambiguate it from other get_agent_* tools.

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

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

The read-only framing and the statement that MCP never signs or submits imply this is an observation/status tool rather than an execution tool. However, it never explicitly says when to prefer this over related tools like get_agent_entry or reconcile_agent_entry_claim, so the usage guidance remains 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 readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the safety profile is fully covered. The description adds 'server-authoritative' and 'replay' context, which gives some behavioral insight beyond the annotations, though not deep detail about response size or edge cases.

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

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

The description is one tight sentence with zero filler. 'Read' is front-loaded, and the resource is specified precisely.

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

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

For a read-only, idempotent, non-destructive tool with one parameter, a complete input schema, and an output schema, the description is sufficient. An agent can determine how to invoke and what to expect without additional information.

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

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

Schema description coverage is 100% for the single required parameter matchId, and the pattern is fully documented. The description adds no extra meaning beyond identifying that the tool operates on one match; the schema already documents the parameter.

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 ('Read') and a specific resource ('server-authoritative state and replay for one SWARM SYNC match'). The title and description together clearly distinguish it from sibling tools like get_arcade_player_status or play_arcade_move by focusing on match state and replay.

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 clearly implies the tool is for reading a single match's state and replay. It does not explicitly name alternatives or when not to use it, but the singular 'one match' plus 'read' gives strong contextual 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, openWorldHint, idempotentHint, and non-destructive behavior, so the description's safety profile is well covered. The description adds a meaningful constraint: the caller needs a 'game-only handle', not a general session handle. It could still explain more about what happens with an invalid/expired handle, but it is not materially misleading.

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 one compact sentence that front-loads the action and the target resource. There is no redundant phrasing, and the caveat about the game-only handle appears naturally at the end without wasting tokens.

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?

This is a simple read-only tool with a single parameter, full schema coverage, and an output schema, so the description does not need to document return values. The main missing piece is why not use a similar sibling tool, but that gap is already captured in the Usage Guidelines dimension.

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

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

Schema description coverage is 100% and the single required parameter, sessionHandle, is already described as a '30-day game-only session handle.' The description's 'using a game-only handle' reinforces that semantics but does not add meaningful new meaning beyond the schema.

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

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

The description clearly states a verb and resource: 'Read queue, match, and weekly-list status' and ties it to a specific input type ('using a game-only handle'). The title further clarifies the domain ('my SWARM SYNC status'). However, it does not explicitly differentiate from sibling read tools such as get_arcade_match or get_agent_entry_status, so it stops short of fully standing apart.

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

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

The description implies this is for reading status with a game-only handle, but gives no explicit when-to-use guidance, prerequisites, or exclusions. It does not name any alternative sibling tool or explain when an agent should pick this over similar status-readers. An agent must infer the intended use case from the title and schema.

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's 'Read' aligns with annotations readOnlyHint=true, idempotentHint=true, and destructiveHint=false, with no contradiction. It adds the concrete data dimensions (phases, decision states, allocation limits, v5 readiness) beyond the annotations, but does not mention edge behaviors like stale data or error conditions — a minor gap given the annotation coverage.

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

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

A single front-loaded sentence with zero filler — every word contributes either the action, the scope, or the contents being read. Well below any size concern and perfectly scannable.

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

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

For a parameterless, read-only status tool with an output schema, annotations, and a clear workflow placement, the description covers everything an agent needs to select and invoke it correctly. There are no operative 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?

The tool has zero parameters and 100% schema coverage, so the schema leaves no ambiguity. The description adds no parameter syntax needs since none exist, but it does clarify what data the agent obtains; this is the appropriate baseline for a parameterless tool.

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

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

The description uses a specific verb ('Read') with a clear resource ('Census') and enumerates exactly what is read: phases, decision states, allocation limits, and v5 contract readiness. This clearly distinguishes it from the many sibling get_*tools targeting other domains (agent entry, market, marketplace, arcade).

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 'before preparing a decision' places the tool in an explicit workflow context — it is the read step that precedes the many prepare_* sibling tools. It does not explicitly name alternatives or state when not to use it, which keeps it from a 5.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds useful domain context: NFH-owned, rehearsal, WETH, and openSea/mainnet exclusions. It doesn't discuss return format or pagination, but the output schema is available and this is a straight 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?

Two sentences with no wasted words. The action and target are front-loaded, and the anti-scope warning ('Never OpenSea or mainnet') is a powerful, minimal guard against misuse.

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

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

For a parameterless, read-only tool with a rich output schema and clear annotations, this description covers the essential selection context: what the tool reads, whose data, and on which network. Nothing important 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?

There are no input parameters, so the schema carries no parameter burden. The description appropriately scope the operation to a fixed resource, which is the only needed parameter-related context for this tool.

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

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

The description uses a specific verb ('Read') and names the precise resource: the NFH-owned Sepolia rehearsal marketplace, including collection and WETH configuration. This clearly distinguishes it from the sibling 'get_mainnet_marketplace_status' by highlighting both the environment (Sepolia) and ownership scope (NFH-owned).

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

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

The description gives a clear context for when to use the tool—Sepolia rehearsal marketplace config—and an explicit exclusion, 'Never OpenSea or mainnet.' It doesn't directly name an alternative tool, but the sibling list and wording make the mainnet alternative evident.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and the 'Read' verb is consistent with them. The description adds non-obvious behavior the annotations cannot: the status is 'quorum-backed' rather than a simple node read, and it reveals that preparation tooling only opens when the exactly permitted marketplace is unpaused — a meaningful gating behavior for agents planning transactions.

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 front-loaded intent and no filler; the first sentence names the resource, the second adds the gating condition. The second sentence's phrasing ('for the exact unpaused, promised marketplace') is slightly awkward, costing a minus.

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

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

For a zero-parameter tool with an output schema and strong annotations, the description carries a light context, and it covers the two things an agent needs: what the status describes (market and transfer validator readiness) and why it matters (preparation opens only in the exact permitted state). The only real gap is explicit sibling differentiation, which would fully close the remaining ambiguity.

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, which gives a baseline of 4 per rubric, since there is no parameter surface for either schema or description to document. No parameter-semantics burden falls on the description.

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

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

The first sentence names a specific verb and resource: 'Read quorum-backed Ethereum market and transfer-validator readiness,' and the title pins it to the 'live NFH Ethereum marketplace status,' which is the intent of the tool. The 'quorum' and 'Ethereum/mainnet' framing hints at how this differs from get_internal_marketplace_status or get_market_status, though the distinction is not spelled out.

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

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

The second sentence implies when to call this — 'preparation opens only for the exact unpaused, permitted marketplace' — suggesting agents should check this before prepare_mainnet_* operations. But no sibling is named explicitly and no conditions for choosing this over get_internal_marketplace_status or get_market_status are stated, so Usage Guidelines rest on interpretation.

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

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

The annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint false. The description's read-only and 'never posts or fulfills orders' largely restate those annotations rather than adding new behavioral details like pagination, auth, or rate limits. This is acceptable given the annotations, but the description adds only minor extra context.

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

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

Two succinct, front-loaded sentences with no filler: the first names the data categories, the second reinforces the read-only boundary. Every word contributes to selecting or using the tool correctly.

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

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

For a zero-parameter, read-only tool with an output schema, the description provides enough information about the tool's domain and contents. It could be stronger by explicitly naming siblings like get_market_status or the prepare_* tools, but nothing essential is missing for calling this tool correctly.

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

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

The tool has zero parameters, so there is no parameter documentation burden. The schema coverage is 100%, and the baseline for a zero-parameter tool is 4. The description does not need to clarify any parameters.

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

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

The description states a specific verb ('Read') on a specific resource ('aggregate listings, bids, one-hour claims, and 24-hour transfers'). It also distinguishes itself from the many prepare_* transactional siblings by explicitly saying 'never posts or fulfills orders', so an agent can differentiate this read tool from the write/transaction tools.

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

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

It clearly says what this tool is for: reading the aggregate market feed components. The line 'Read-only; never posts or fulfills orders' gives an explicit exclusion for transactional operations, though it does not name a specific alternative tool to use in those cases.

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 establish read-only, idempotent, and non-destructive behavior, so no contradiction is present. The description adds meaningful context by enumerating exactly what is read: contracts, fees, provider, activation state, and wallet-approval boundary, which goes beyond the 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?

One sentence, front-loaded with the primary action ('Read'), and every phrase adds value. It covers scope and usage timing without any filler.

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

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

For a zero-parameter read-only tool with an output schema and strong annotations, the description is complete. It explains what the call returns, when to call it, and leaves no operational 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?

The tool has zero parameters, so there is no parameter burden for the description to carry. The baseline of 4 applies, and the description appropriately focuses on output scope rather than input semantics.

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

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

The description states a specific verb ('Read'), resource ('canonical market contracts, fees, provider, activation state'), and a clear scope. It is meaningfully distinct from siblings like get_internal_marketplace_status or get_mainnet_marketplace_status through the word 'canonical'.

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 'before any market action' provides explicit timing guidance for when to use this tool. It does not explicitly name alternatives or when-not-to-use cases, but the canonical scope implies the boundary clearly enough.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint), and the description is consistent with them, so no bar adjustment caused. It adds genuinely useful context: receipts arrive in three distinct states (observed, confirmed, finalized) and prepared/unsubmitted actions are filtered out, which tells an agent it is not seeing the pipeline of pending work.

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, no filler: the first fronts the verb, resource, and state scope; the second adds one high-value exclusion. Every word earns its place, and nothing paraphrases the title 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?

For a zero-parameter, read-only tool with an output schema and rich annotations, the description is nearly complete: it says what is read, in what states, and what is excluded. The only real gap is the unstated relationship to the similarly named get_census_status sibling, which an agent may need to disambiguate.

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 no parameters, so the 4-baseline applies and there is no semantic burden on the description. Nothing about parameters is missing because nothing needs to be said.

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?

Identifies a specific verb and resource: read chain-backed Census receipts plus their observed/confirmed/finalized state. The statement that prepared actions are excluded clearly distinguishes it from the many prepare_* sibling tools, though it never names its closest comparison, so it stops short of full sibling differentiation.

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

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

The exclusion line ('Prepared actions are excluded') gives implied guidance about what this tool is not for and hints that prepare_census_receipt is the path for pending work. However, there is no explicit when-to-use statement, no named alternative tool to route to, and no guidance versus the similarly named get_census_status sibling.

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

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

The annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, and the description is consistent with them in all respects, so there is no contradiction. On top of that, the description discloses two non-obvious behavioral features: the tool performs a "live ownership verification" rather than just reading cached state, and it grants only coordination identity. This justifies a score above the baseline 3 for a third 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 definition is two very short sentences with no overhead. The first sentence contains the essential purpose and verification condition, and the second sentence disambiguates the scope of the binding—safe trading and no loss of security. There is no filler, and every word contributes to selection or invocation.

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, four fully-documented parameters, and a generous set of annotations (read-only, idempotent, not destructive), the agent is well-equipped. The marginal gap is that the description doesn't describe what happens when live ownership verification fails, which could matter in some invocation paths, but for a read-verification tool this is a minor gap.

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

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

All four parameters have detailed descriptions in the schema itself (100% schema-description coverage), including an exact nested transport object with an enum of "local_process", "shared_store" and "streamable_http". The description itself adds no extra information at the parameter level, stop that, so the standard baseline of 3 applies.

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

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

The description states the exact action and resource: "Read one Tasq binding after live ownership verification." It uses a specific verb, a specific object, and a clear qualifier, and it separates the read named in the title "current NFH-authenticated Tasq principal-binding" from the creation-oriented sibling prepare_tasq_principal_binding. The added clause "never wallet or effect authority" further reduces ambiguity about what result the binding has.

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

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

The description gives a clear context for use: retrieving a binding after "live ownership verification," i.e., the read-only check of an existing binding. It doesn't explicitly name alternatives or say, "when not to use," but the prior is strongly implied by the read-only wording and the existence of the sibling tool. This is clear context without exclusions, so it earns a 4, not a higher 5.

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

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

Annotations already establish readability, idempotence, and non-destructiveness. The description adds value by disclosing that direct actions are gated on this compatibility/royalty state, which is meaningful domain behavior beyond the annotation metadata.

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 cover the core purpose and the important behavioral consequence with no filler. The active read action is stated first, and the disabling consequence is given after, which is a logical and efficient structure.

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

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

For a zero-parameter, read-only, idempotent status tool, the description is complete. The presence of an output schema means the return structure is already available to the agent, and the description supplies the essential domain gate context without requiring more.

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

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

The tool has zero parameters and the input schema is empty with 100% schema description coverage. The description does not need to explain parameters, and the no-parameter baseline makes this appropriate.

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

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

The description names a specific verb ('Read'), a concrete resource ('TokenWorks/FWA compatibility and royalty gate'), and the consequence of that gate. This makes the tool's role easy to distinguish from the many other get_* tools, which concern distinct domains such as marketplaces, agents, and census status.

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

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

The second sentence implies the tool is the place to check whether direct actions are currently allowed, since they stay disabled until the gate passes. No alternative or explicit 'use when' condition is named, but the context is clear enough for an agent to route to this tool for a pre-check.

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 explicitly discloses that the tool 'changes only off-chain game state,' which is useful context beyond the annotations. This aligns with readOnlyHint=false and adds a meaningful behavioral boundary that a user needs to know before invoking it.

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

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

The description is two focused sentences with no filler. The core action is stated first, and the essential side-effect disclosure is placed immediately after.

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

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

For a one-parameter tool with a high-coverage schema and an output schema, the description is largely complete. The only significant gap is explaining the exact meaning of 'different current owner' and when pairing is possible, but this does not prevent the description from being useful in most call scenarios.

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

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

There is a single required parameter with 100% schema description coverage, so the schema already documents the session handle. The description does not materially deepen the parameter semantics, beyond implying that the session may determine who the 'current owner' is.

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 action ('join') on an arcade game resource and tells the agent two concrete behaviors: joining the cooperative queue or pairing with a different current owner. It is clear enough to distinguish the tool from the many prepare_/get_ siblings, though 'different current owner' remains somewhat ambiguous.

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

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

No when-to-use or when-not-to-use guidance is provided, and no alternatives among the arcade siblings are mentioned. The description does not say whether joining requires an established session, whether it should be used before play_arcade_move, or what conditions make pairing applicable.

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

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

The annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds non-obvious behavioral context by stating that these receipts prove acceptance only and not payment or transaction authority, which prevents the agent from over-interpreting the list.

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

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

The description is two short sentences that front-load the core action and resource, then add a clarifying caveat. There is no filler, repetition of the title, or unnecessary detail.

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?

This is a simple read-only list with one optional parameter, rich annotations, and an output schema, so the description covers the important domain semantics. The only meaningful gap is the missing explanation of the limit parameter, which has a modest impact given the schema already enforces its range.

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

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

Schema description coverage is 0%, and the description does not explain the optional `limit` parameter or its meaning, such as pagination or maximum number of returned receipts. The description relies entirely on the parameter name, so it does not compensate for the missing schema-level parameter documentation.

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

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

The description states a specific verb and resource: 'List dual-signed ACCEPT receipts.' It immediately clarifies that this lists acceptance receipts, not work or payment documents, so an agent can tell it apart from broader list-like tools.

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

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

The phrase 'They prove acceptance, not payment, capability, transaction authority, or selection' gives implied guidance about when to trust the output, but it does not explicitly name alternatives such as list_returned_work or say when this tool should be preferred. Usage is largely inferred from the purpose rather than 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 already establish readOnly, idempotent, non-destructive behavior. The description adds meaningful non-obvious semantics: the list is based on unexpired owner-signed heartbeats, not on actual liveness or authority. This is exactly the kind of behavioral context that an agent cannot safely infer from annotations alone.

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 carry substantive information with no filler. The primary action and resource are front-loaded, and the crucial interpretation caveat follows immediately. Every clause earns its place.

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

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

Given that this is a read-only list operation with a rich output schema and strong annotations, the core semantics are well covered. The main gap is parameter behavior such as default limit and optional tokenId filtering. Otherwise the caveat about runtime and wallet authority is exactly the additional context an agent needs.

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 only 50%, and the description itself adds no parameter-level detail. It does not explain how limit behaves, whether tokenId acts as a filter, what the default behavior is, or how the fields interact. The tokenId parameter has a schema description, but the main tool description provides no compensating meaning.

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

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

States a specific verb ('List') and a precise resource ('unexpired owner-signed presence heartbeats'). The caveat that presence proves neither continuous runtime nor wallet authority prevents the misleading interpretation that 'active' means running or authorized. This clearly differentiates it from narrower agent-state or status tools among the siblings.

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

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

The description gives clear context for when the tool is applicable: it lists presence heartbeats only. The warning that presence proves neither continuous runtime nor wallet authority implicitly tells the agent not to use it as evidence for those things. It stops short of naming explicit alternative tools or conditional decision rules, which keeps it from a 5.

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

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

Annotations already declare the operation safe, read-only, idempotent, and non-destructive. The description adds meaningful semantic context beyond that: missing evaluations make a receipt incomplete, and receipts themselves grant no authority. This is useful non-obvious behavior information not present in the 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?

The description is compact and front-loads the core purpose in one sentence, then adds one high-value semantic caveat in the second. There is no wasted wording, no repetition of the title, and the structure makes it easy for an agent to scan quickly.

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

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

For a read-only, limited-purpose list tool with only two simple parameters and an output schema, the description covers the critical context: the receipt lifecycle, promotion decision inclusion, the meaning of missing evaluations, and the non-authoritative nature of receipts. A bit more on parameter-level intent would improve it, but nothing is missing at a blocking level.

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

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

The schema already covers tokenId as an NFH token id and provides valid constraints for limit. The description adds no direct parameter guidance, leaving any parameter ambiguity only mildly addressed. Since schema coverage is not complete for limit, a score of 3 is appropriate: adequate but not enriching.

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 the exact operation: list ACT → RECORD → EVALUATE receipts and promotion decisions. It clearly identifies the resource, the lifecycle stage, and the fact that this is a read/list operation, distinguishing it from sibling tools like list_agent_requests or list_accepted_work.

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

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

The intended scope is clear: this is the tool for NFH learning receipt and promotion-decision listing. It does not explicitly name alternatives or exclusions, but the lifecycle language and resource type make when to reach for this tool sufficiently obvious relative to the other list 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 indicate read-only, open-world, idempotent, and non-destructive behavior. The description adds meaningful extra context: work is 'current' and, crucially, that task text is untrusted data and not instructions, proof, escrow, or authority — a valuable safety-relevant behavior beyond what annotations or schema convey.

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

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

The description is two sentences with no filler. The primary function is front-loaded, and the second sentence earns its place by giving the security-relevant 'untrusted data' warning in a compact way.

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

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

With a read-only annotation set, a provided output schema, and a single optional limit parameter, the description covers the essential intent and the notable untrusted-data warning. It could have mentioned pagination, ordering, or relationship to sibling work-request statuses, but the structured fields already supply much of what an agent needs.

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

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

There is one optional parameter, limit, with clear min/max constraints in the schema but no description. The tool description does not add any meaning about how the limit behaves. The parameter is simple and self-explanatory enough, but the description still fails to add semantic value beyond the input schema.

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

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

The description states a specific verb+resource ('List current holder-signed work requests') and makes the resource type clear enough to distinguish from sibling list tools like list_accepted_work and list_returned_work. The title adds a helpful second label ('Agent Wanted requests').

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

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

There is no explicit guidance on when to use this tool versus alternatives. The phrase 'current holder-signed work requests' implies a scope, but it does not tell an agent when to choose this over list_accepted_work, list_returned_work, or get_agent_next_action.

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 establish that this is read-only, idempotent, open-world, and non-destructive, so the description only needs to add value beyond those flags. It does by warning that public game data is untrusted and that wins do not guarantee claims, which is a meaningful behavioral caveat.

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

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

The description is two short sentences with no filler. The first sentence enumerates the exact contents of the result, and the second provides a non-obvious caveat. Every part 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 simple read-only list tool with an output schema and strong annotations, the description is largely complete: it identifies what is returned and warns about data trust. The only clear gap is that limit behavior is not mentioned, but the single optional bounded parameter and output schema keep this minor.

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

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

There is only one optional parameter, limit, but schema description coverage is 0% and the description does not explain how limit affects results. The field name is somewhat self-evident, but a one-line clarification such as 'limits the number of returned lobby entries' would be needed to compensate.

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 explicitly states the verb and resource: it lists Arcade games, tool routes, waiting NFHs, and verified weekly winners. This clearly distinguishes it from sibling tools such as join_arcade_game, play_arcade_move, and get_arcade_match, which suggest different operations.

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

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

The description gives no explicit guidance on when to use this tool instead of alternatives. There is no mention of when to list the lobby versus joining a game, playing a move, or fetching match details, so the agent must infer usage context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context beyond those annotations: the listed items are self-reports and carry no proof of acceptance, payment, escrow, or capability.

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

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

The description is two short sentences, front-loads the core action and resource, and keeps the disclaimer in the second sentence. Every word contributes meaning with no fluff.

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

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

For a read-only list tool with an output schema and strong annotations, the description covers the data semantics well. However, it does not explain the requestId parameter, which is likely the main filtering mechanism, leaving a clear gap in complete call context.

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

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

Schema description coverage is 0% and the description gives no extra meaning for 'limit' or 'requestId'. The schema only provides type-level constraints, so an agent is left to infer what requestId filters and whether limit applies globally or per request. The description does not compensate for the missing parameter documentation.

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

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

The description uses a specific verb and resource: 'List worker-signed RETURNED_UNVERIFIED submissions.' It further clarifies what the items are not ('not acceptance, payment, escrow, or capability proof'), making its scope far clearer than the title alone and distinguishing it from related tools like list_accepted_work.

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 clearly frames when this tool is relevant—when you need worker-signed returned/unverified self-reports. The explicit caveat that they are not acceptance or payment proof effectively tells an agent not to use this tool for verified acceptance data, although it does not name the alternative sibling explicitly.

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 mark the tool as read-only, idempotent, and non-destructive. The description adds important beyond-annotation behavior by warning that results and hashes are unverified and must be decoded and validated before execution, which is valuable trust/safety context for an open-world data source.

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 with no filler. The first states what the tool does and the second adds an important safety caveat. Everything earns its place and the content is easy for an agent to scan.

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 read-only annotations, existing output schema, and parameter documentation, the description provides the essential context: source, filter shape, and validation caution. It does not need to restate return or pagination details because the schema and output schema cover those, making the definition largely complete for a listing 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 description repeats the AND-combined and 1–8 trait constraints already present in the schema, but adds little about the 'next' cursor or 'limit' semantics. Since schema coverage is fairly high and the schema itself documents the parameters reasonably well, this is a minimum-viable score rather than a strong one.

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

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

The description clearly states a specific action and resource: querying OpenSea for trait offers using 1–8 AND-combined traits. The tool's purpose is instantly understandable and is reasonably distinct from generic list/search tools, though it does not explicitly name or contrast sibling alternatives.

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 conveys that this is the tool for listing OpenSea offers filtered by traits, which is clear contextual guidance. It does not explicitly state when not to use the tool or name alternatives like find_best_order or search, so it falls short of the 5-level 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 do the heavy lifting for readOnlyHint and destructiveHint. The description adds valuable behavior beyond annotations by explicitly stating the session handle grants no wallet or claim authority, which is a critical security/behavioral nuance. It also clarifies 'Commit' implies a state mutation, consistent with the 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?

The description is two sentences, front-loaded with the core action and resource, and every token adds value. The security/authority caution in the second sentence is important and not redundant. No filler or repetition.

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

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

With a full input schema for all three parameters, a defined enum, an output schema, and safety annotations, the description only needs to add the non-obvious operational details. It does that through the move types and the wallet authority warning. A minor gap is lack of mention that a prerequisite match/session must exist (e.g., from join_arcade_game), but this is reasonably inferable.

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

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

Schema description coverage is 100% and includes detailed types, patterns, and enums for all three required parameters. The description adds no extra parameter detail beyond what the schema already provides, so the baseline 3 applies.

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

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

The description uses a clear verb 'Commit' with specific resources (SCAN, LINK, or BUILD) and the object 'current wave'. It distinguishes this tool from the game-related siblings like play_signal_city by naming the arcade move types and implying the arcade context. 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?

The description gives clear context: use this to commit a move for the current match wave. It implicitly differentiates from prepare_* and join_* tools by focusing on the actual move execution. The note about the handle granting no wallet/claim authority also functions as a contextual exclusion, though it doesn't name alternatives explicitly.

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?

It discloses important non-obvious behavior: chat is public untrusted text, and the handle grants no wallet or the authority. These are genuine behavioral caveats beyond the passive readOnly/openWorld annotations, which help the agent avoid security mistakes. It adds meaningful context without contradicting 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?

Two tightly packed sentences carry high signal density, front-loading the main purpose and then adding the security/privacy caveats. No word is wasted, and the semicolon-separated action list is easy to scan for both agents and humans.

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 primary game actions well, but the tool exposes 11 enum actions, and descriptions are not given for jump/sound/collect/heartbeat, which leaves ambiguity about their exact effect and whether a value should be supplied. The presence of an output schema and high annotation coverage reduces the burden; still, this is a materially incomplete overview for the full action set.

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

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

The schema already covers every parameter with descriptions (100%), so the baseline for this dimension is 3. The description mostly paraphrases the value schema (e.g., 'travel by world id', 'chat is 1%-180 char text') rather than adding deeper per-action semantics; there is no added guidance for underrepresented actions like jump/sound/collect/heartbeat.

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

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

The description opens with a specific verb ('Play') and a clearly scoped resource (a game-only session in Signal City), then lists the concrete action classes: travel by world id, explore left/right, interact, toggle autoplay, and chat. It distinguishes itself from sibling tools by explicitly stating it grants no wallet or claim authority, so an agent can tell it apart from claim/wallet tools.

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

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

The phrase 'game-only handle' establishes the required context for using the tool, and 'Grants no wallet or approval authority' acts as a clear when-not signal. It could go further by naming sibling alternatives (e.g., enter_signal_city or play_arcade_move) or stating conditions for each action, but the context is solid.

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 readOnlyHint and destructiveHint in annotations, the description adds valuable context: both wallets sign identical text, owner and worker are distinct, and workerTokenId ownership is a prerequisite. This goes beyond annotation declarations without contradicting readOnlyHint.

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 purpose, no filler or repetition. It conveys the core operation, participants, and conditions efficiently.

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

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

The delegate formatting is optional and the description does not explain the learning object, but that is detailed in the input_schema and output_schema. Given the schema and annotations, the description is enough to guide successful 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?

The schema already covers 83% of parameters, so the high baseline. The description adds meaning by connecting workerTokenId to active worker ownership and forcing a distinct owner/worker relationship. This is useful beyond the 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?

Description states a concrete verb and resource: prepare a readable ACCEPT receipt. It also names the involved parties, making clear this op differs from sibling tools like prepare_accept_offer or prepare_returned_work.

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 condition 'worker currently works' is clarified, but there is no explicit when-to-use vs alternatives and no exclusion guidance. Context is implied rather than 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 already declare readOnlyHint=true, but the description adds a crucial behavioral guarantee: 'Never signs or broadcasts.' This goes beyond generic read-only semantics and clearly informs agents that this step only constructs unsigned fulfillment and does not send it to the network.

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

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

Two compact sentences, front-loaded with the action and adding the critical safety caveat second. No wasted words; every phrase contributes to disambiguation or safety understanding.

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

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

Given the simple 3-required-param schema, the presence of an output schema, and annotations covering the read-only behavior, the description provides sufficient context. It identifies the domain (Seaport fulfillment), the specific offer type (item/collection/trait NFH), and the boundary of the operation (no signing/broadcasting).

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

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

The input schema already covers all three parameters with clear descriptions (EVM address, NFH token id, OpenSea order hash), so schema coverage is 100%. The description does not add additional parameter semantics, earning the baseline score.

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

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

The description clearly identifies the tool's action ('Prepare Seaport fulfillment'), its resource ('selected item, collection, or trait offer and matching NFH'), and explicitly distinguishes it by saying it 'never signs or broadcasts.' This separates it from signing/sending tools and from mainnet/internal accept variants, making the purpose unmistakable.

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

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

The description gives a clear context for when to use it: when an NFH offer needs Seaport fulfillment prepared without signing or broadcasting. It does not explicitly cite alternative siblings like prepare_internal_accept_offer or prepare_mainnet_accept_offer, so exclusions are implied rather than stated, but the NFH focus provides enough 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 the operation as read-only, idempotent, and non-destructive. The description adds meaningful context beyond those annotations: it clarifies that the output is off-chain readable text rather than an actual transaction or claim. There is no contradiction between the description and 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?

The description is two short, purposeful sentences with no fluff. The core purpose is stated first, and the clarifying exclusion is placed at the end, making it easy for an agent to quickly understand the tool's role.

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 one-parameter tool with an output schema and rich annotations, the description provides nearly all necessary context: off-chain, 24-hour duration, reservation, and non-transaction nature. It relies on the title for the 'empty-wallet' qualifier, but that is acceptable since the title is provided as context.

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

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

Schema coverage is 100% and the only parameter, wallet, is documented as an EVM address with a pattern. The description does not add much parameter-specific meaning, but that is acceptable because the schema already fully describes it. Baseline 3 applies here.

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

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

The description clearly identifies the tool as preparing readable text for a 24-hour off-chain reservation, which is a specific verb and resource. It also distinguishes itself from other tools by explicitly stating it is not an NFT claim or transaction, separating it from sibling tools like prepare_agent_entry_claim and prepare_mainnet_buy.

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 clearly: use this tool when you need to prepare human-readable text for a 24-hour off-chain reservation. It provides exclusions, stating it is not for NFT claims or transactions, which helps the agent avoid misuse. It could be stronger by naming a specific alternative tool, but the guidance is sufficient.

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 the tool read-only, idempotent, and non-destructive. The description adds the useful behavioral detail that 'evidence stays unreviewed and creates no mint right,' which tells the agent this preparation does not change review status or grant mint entitlement. This goes beyond what the annotations alone state.

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

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

The description is two short, front-loaded sentences with no filler or repetition of the schema. The first sentence states the core action and the second adds a key caveat. Every phrase earns its place while keeping the description compact.

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

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

Given a simple two-parameter schema, a rich set of annotations, and an output schema, the description covers the main preparation behavior and policy caveats. It doesn't, however, explicitly place itself among the many prepare/submit siblings, so an agent might still struggle to choose the right step in a longer workflow. That slight ambiguity keeps it from a 5.

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

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

The input schema thoroughly documents both parameters with patterns and descriptions, giving 100% schema description coverage. The description's phrase 'one activity hash' aligns with the evidenceHash parameter but adds no new detail about reservationId or how the two parameters interact. With complete schema coverage, baseline 3 is appropriate.

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

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

The description gives a clear verb and object: 'Prepare readable text binding one activity hash.' It also adds a meaningful boundary by noting the operation 'creates no mint right,' which helps separate it from claim/mint tools. However, it doesn't explain what the readable text is for or how it fits into the agent-entry flow, leaving some purpose ambiguity.

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

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

There is no explicit guidance about when to use this tool versus siblings like submit_agent_entry_activity, prepare_agent_entry_claim, or prepare_agent_entry. The caveat about 'no mint right' implies a context, but it doesn't directly state prerequisites or routing conditions. An agent would have to infer usage from the tool name and sibling list.

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 read-only, idempotent, and non-destructive behavior, but the description adds important context beyond them: it verifies issuer authorization against active reservation state, returns an unsigned claim, and never signs or broadcasts. This meaningfully helps the agent avoid expecting a signed or submitted transaction.

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 carry the essential information: what the tool does, what it returns, and what it explicitly does not do. There is no filler or repetition of schema content.

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

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

With full schema coverage, rich annotations, and an output schema, the description is mostly complete for safe invocation. It could still be slightly stronger by noting the expected state prerequisite for the 'active reservation' and explicitly routing the agent to a signing/broadcasting sibling when actual submission is intended.

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

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

The schema already fully describes both required parameters, so the baseline is 3. The description adds that authorization is checked against the active reservation and activity hash, but it does not elaborate much on the exact structure of authorization or the role of issuerSignature beyond what the schema provides.

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: verify issuer authorization, then return an unsigned claim call. It also distinguishes the tool from signing/submitting siblings by explicitly saying 'Never signs or broadcasts,' making the tool's role unambiguous.

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

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

The description gives clear usage context: use this when verification against an active reservation and activity hash is needed and an unsigned claim is acceptable. It implicitly warns against using it when signing or broadcasting is needed, though it does not name a specific alternative sibling such as claim_as_agent.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the baseline safety profile is covered. The description adds meaningful context by clarifying that no signing or publishing occurs and that actual swarm promotion is curator-gated. This goes beyond the annotations without contradicting them.

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

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

Two compact sentences carry the full behavioral scope, exclusion, and context. Every phrase earns its place, and the core action is front-loaded.

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

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

For a read-only prepare tool with a fully documented schema and an output schema, the description provides the necessary usage, side-effect boundaries, and gating context. An agent can reliably select and invoke this tool without missing critical information.

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

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

Schema description coverage is 100%, so the input schema already explains every parameter. The description does not materially add parameter-level semantics beyond reinforcing that the text is owner-signable and tied to one tested proposal. This matches the baseline for high schema coverage.

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

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

The description states a specific verb and resource: 'Prepare owner-signable PROMOTE or REJECT text for one tested skill proposal.' It also sharpens scope and differentiates from siblings by explicitly saying it 'Never signs or publishes; swarm promotion is curator-gated.'

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 that this is the preparation step for a tested skill decision, and explicitly states it does not sign or publish. It does not name specific sibling alternatives or provide when-not-to-use scenarios, so it stops short of a full 5.

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

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

Annotations already carry readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the read-only nature is covered. The description adds useful behavioral context: output is readable EIP-191 text, the heartbeat has a 30-minute window, and the owner must review and sign. It does not contradict any 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?

Two sentences with no filler. The core action, the nature of the artifact, the duration, and the signing workflow are all packed concisely and front-loaded.

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

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

For a two-parameter tool with a rich output schema and safety annotations, the description covers the main workflow and duration. It could explicitly mention how the tokenId/owner map into the EIP-191 text, but the output schema reduces that need.

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

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

Schema description coverage is 100% and both parameters are documented in the input schema. The description adds marginal context by implying the owner wallet is the reviewer/signer and the token ID is tied to the NFH heartbeat, but it does not at significant parameter-specific detail beyond the schema.

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

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

The description states a clear, specific action: prepare readable EIP-191 text for a 30-minute public presence heartbeat. It also distinguishes this from delegated heartbeat tools by emphasizing the owner wallet reviews and signs, which separates it from prepare_agent_presence_delegation and prepare_delegated_agent_heartbeat.

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

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

The description implies the usage context: the owner wallet needs signable text for a public presence heartbeat before signing. However, it does not explicitly state when to prefer this tool over siblings like prepare_delegated_agent_heartbeat or prepare_agent_presence_delegation, leaving the selection 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 goes beyond the annotations by clarifying the security boundary ('Grants no financial or account authority') and the maximum duration ('up to 7 days'). The readOnlyHint=true annotation aligns with 'prepare owner-signable text,' indicating no state change is committed. It does not deeply explain the signature format or that delegation can be freely reversed, but given the annotations the behavioral posture is reasonably transparent.

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

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

The description is one well-formed sentence, information-dense, and front-loads the main action ('Prepare owner-signable EIP-191 text'). Every phrase ('presence-only heartbeats', 'up to 7 days', 'no financial or account authority') earns its place and delivers meaningful boundaries.

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 read-only prepare-purpose, the description covers primary input semantics and the main behavioral constraint. It does not explain defaults or edge cases like what happens when validForHours is omitted, but the output schema can carry the return-value details, and the context is sufficient for an agent to know what is being prepared. A small gap remains around why this versus other delegation counterparts.

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

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

The input schema covers owner and agent as 'EVM address' and tokenId as 'NFH token id', but leaves validForHours without a description. The description compensates by describing the intent: presence-only heartbeats for up to 7 days, which directly explains validForHours in human terms. It does not individually annotate each param, but the semantic gap in the schema is resolved enough.

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

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

The description uses a specific verb ('Prepare') plus a concrete resource ('owner-signable EIP-191 text') and defines the delegation scope: 'presence-only heartbeats for up to 7 days.' This is clear enough to distinguish it from generic prepare_* tools, though it does not explicitly name any sibling tool it should be chosen over.

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 an obvious use case but gives no explicit guidance on when to choose this tool versus alternatives. The sibling list contains related tools such as prepare_agent_presence and prepare_delegated_agent_heartbeat, and the description does not state the condition that should route an agent away from those. It also does not mention prerequisites, such as needing an owner signature context or the fact that this only prepares a text.

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 mark the tool as read-only and non-destructive. The description adds the important boundary that it only formats an EIP-191 request and never signs or publishes, which clarifies offline behavior without contradicting the 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?

Two sentences, front-loaded with the core action and followed by the safety boundary. There is no redundant phrasing or information already present in the annotations or schema.

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

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

With an output schema and annotations present, this is usable for a read-only request-preparation tool. However, with 13 parameters and only 38% schema description coverage, the tool definition leaves several parameter meanings and relationships unexplained, so the contextual picture is incomplete.

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 low at 38%, so the description must compensate for undocumented parameters. It only mentions 'per-agent reward' and 'expiry', leaving payers confusion about maxAgents, rewardType, missionKind, compensation, rewardAmount, rewardCurrency, and expiresInHours, which are not described in the schema either.

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 action and resource: 'prepare readable EIP-191 work-request text' with reward and expiry. It is clear what the tool produces, though it does not explicitly name a sibling tool to distinguish itself from the many other prepare_* tools; 'never signs or publishes' helps disambiguate.

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 useful workflow context: the owner reviews and signs afterwards, publish verifies ownership, and this tool never signs or publishes. However, it does not explicitly state when to choose this tool over the many sibling prepare_* tools, nor any preconditions beyond the general owner-of-token assumption.

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

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

The annotations already declare readOnlyHint true and destructiveHint false, but the description goes further by itemizing exactly what the tool never does: sign, publish, delete history, or change authority. This helps the agent set accurate expectations about the prepared artifact and its side-effect-free boundary.

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

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

The description is two sentences with no filler. The main purpose is front-loaded, and the second sentence provides a tight list of non-actions. Every word carries signal.

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 complete schema coverage, the output schema, and the read-only annotations, the description supplies the necessary operational boundary and scope. It falls just short of full completeness by not describing prerequisites or the follow-up flow after the prepared artifact is produced, but those are not required for invocation given the surrounding schema.

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

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

All six parameters have full schema descriptions, so the input schema already carries the documentation burden. The description adds useful context like 'retested' and 'owner-signable,' but it does not materially extend individual parameter semantics beyond what the schema provides.

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: prepare an owner-signable rollback to a previously promoted, retested skill version. It clearly distinguishes this from the many other prepare_* siblings by naming the rollback objective and the constraints around signing and mutation.

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

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

The description provides a clear usage context: use it when an owner-signable rollback to a promoted, retested skill version is needed. The 'Never signs...' statement also clarifies that this tool is not for actually signing or executing the rollback, though it does not name a corresponding alternate tool for that later step.

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 provide readOnlyHint and destructive hints, and the description adds useful behavior boundaries: it never signs or opens the session. It also supplies non-obvious context about the session being 30-day and game-only. No annotation contradiction is present.

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

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

The description is only two short sentences with no filler. The key action, session constraints, and non-signing behavior are all positioned clearly and economically.

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

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

For a two-parameter, read-only tool with full schema coverage and an output schema, the description provides the essential context. The main missing detail, an explicit pointer to the companion tool that finally signs or opens the session, is not strictly required for selecting or invoking this tool.

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

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

Schema description coverage is 100%, so owner and tokenId are already documented in the input schema. The description does not add meaningful parameter-level meaning beyond mentioning that the output is owner-readable text. This is a standard baseline score for full schema coverage.

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

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

The description clearly states a specific verb and resource: prepare owner-readable text for a 30-day, game-only session. It also clarifies what the tool does not do, namely sign or open the session. It lacks explicit sibling differentiation, but the action itself is unambiguous.

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

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

The description implies this tool is only for the preparation phase and should not be used when signing or opening the session is desired. However, it does not name an alternative tool or provide explicit when-to-use guidance relative to the many sibling prepare_* 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?

The description goes beyond the readOnlyHint and destructiveHint annotations by explicitly saying the tool 'Never signs or submits', a meaningful behavioral boundary. It also clarifies the output is unsigned typed data, but leaves most safety and mutation details to the 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?

Two short, focused sentences: the first gives the precise action and supported decision, the second states the critical non-signing/non-submitting boundary. No redundant wording or restatement of the title.

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

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

Given a rich input schema with enums, a visible output schema, and a modest read-only annotation, the description provides the core behavioral context an agent needs. It could be slightly more explicit about the supplied data being EIP-712-style typed data intended for later signing, but the schema and 'unsigned' part clarify enough.

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

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

The schema already covers 83% of parameters, so the baseline is 3. The description does not add any parameter-level meaning, such as the purpose of reasonHash or the relationship between publicStatement and statementHash, but it does not need to because the schema carries most of the burden.

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: 'Prepare unsigned v5 Census typed data'. It enumerates the three intended decision values and clarifies it does not sign or submit, which sharply distinguishes this from other prepare_* tools.

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

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

The description clearly identifies when to use this tool: to prepare Census typed data for one of three decisions. It also gives explicit exclusion guidance via 'Never signs or submits', though it does not name the specific sibling tools that should be used for signing or submitting instead.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, and the description aligns with these while going further by explicitly saying the tool never signs or publishes. It also adds useful behavioral context about the heartbeat being short-lived and tied to presence-only delegation.

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 concise sentences with zero filler. The core scope sentence comes first and the important non-signing/non-publishing caveat is placed immediately after for clear front-loading.

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

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

For a simple two-parameter tool with full schema coverage and an output schema present, the description is complete. It provides the functional scope, the presence-delegation precondition, and the safety boundary, leaving no critical guidance gap.

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

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

Schema description coverage is 100%, so the schema already explains both parameters: agent is an EVM address and tokenId is an NFH token id. The description adds no parameter-specific meaning beyond that, which is acceptable since the schema is already clear.

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

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

The description clearly names the action ('prepare'), the resource ('a short-lived heartbeat'), and the exact scope ('agent with an active presence-only delegation'). The qualifier 'Never signs or publishes' gives an explicit boundary that distinguishes it from the many sibling prepare_* and submission tools.

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

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

It supplies a precise usage condition: only for agents with an active presence-only delegation. It does not name a specific alternative tool to choose instead, but it communicates a strong exclusion ('Never signs or publishes') which helps the agent understand when not to rely on this for publishing.

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 the operation read-only and non-destructive, so the bar is lower; the description goes further by disclosing the specific error code, the fail-closed posture, and that no transaction steps are produced. This adds meaningful behavioral context not available in the annotations alone.

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 dense sentence that fronts the core behavior (fail closed with a specific error and no steps) and then gives the reason. Zero wasted words, and the title immediately establishes the resource.

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

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

The output schema exists, so return-value documentation is already structured. However, the description is missing the 'evaluation' context: it does not say when the safety check passes, what the successful path looks like, or how this tool differs from the closely named prepare_accept_offer/prepare_mainnet_accept_offer. enough for seasoned agent but has a noticeable gap for exact routing.

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

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

Schema description coverage is 100%, so the input schema already documents all three parameters. The description adds nothing about the parameters, but it does not need to; baseline 3 is appropriate when the schema carries the parameter burden.

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

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

The title identifies the resource and intent (internal-marketplace offer acceptance safety), and the description clarifies the actual behavior: a fail-closed guard that returns CONTRACT_PRICE_BINDING_REQUIRED with no transaction steps. This goes beyond the name by explaining the specific failure mode, though it does not make the comparison to sibling accept-offer tools in text.

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

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

The description explains why the tool fails (acceptOffer() does not bind reviewed economics), which implies the context for invoking it. However, there is no explicit guidance on when to use this tool versus prepare_accept_offer or prepare_mainnet_accept_offer, and no mention of what successful use would return.

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 provide readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the description does not need to restate safety. It adds behavioral context beyond the annotations by noting that the purchase is prepared at an exact listed price and that settlement will pay royalty, explaining the intended downstream effect.

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

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

The description is a single, compact sentence that places the most critical constraints front and center: exact price, internal marketplace, and royalty behavior. There is no filler or redundancy.

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

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

Given the output schema, 100% parameter coverage, and strong annotations, the description is nearly complete for safe invocation. It could be slightly clearer about how this relates to the mainnet counterpart or whether the preparation call itself has any observable effect, but those gaps are minor because readOnlyHint already covers the safety profile.

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

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

Schema description coverage is 100%, so parameters are already well-documented. The description adds useful emphasis that priceWei must be the exact current listed price, but it does not add meaning for buyer or tokenId beyond what the schema already provides.

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 (prepare buy()) and resource (the NFH-owned Sepolia internal marketplace), and adds the key condition of executing at the exact listed price. This clearly distinguishes it from siblings like prepare_mainnet_buy or prepare_listing.

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