NOT FOR HUMANS

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

Beyond the annotations, the description discloses meaningful behavioral details: verification checks, one-time/unminted status, 24-hour duration, and that only signature and message hashes are stored. This adds real transparency about side effects. It could mention failure behavior more explicitly, but the added context is strong.

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

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

The description is compact, front-loaded, and every sentence carries essential information. No filler, no repetition of the title, and it includes the most important operational constraint in the first sentence.

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

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

Although the tool is simple in parameter count, the payload is completely unspecified, and the relationship to the sibling prepare/claim tools is not explained. The description gives a good high-level contract but not enough operational detail for an agent to confidently construct a valid call.

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%. The description references the signature and message hashes, but the payload parameter is an opaque nested object with additionalProperties allowed, and its contents are never explained. An agent cannot confidently construct the payload from the provided information.

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 action: verifying a wallet signature and zero-NFH balance, then recording a one-time 24-hour unminted reservation. It does not explicitly distinguish itself from sibling preparation tools like prepare_agent_entry, but the behavior is concretely specified beyond the title alone.

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

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

Preconditions are implied: the tool should be used when there is a signed Agent Entry reservation and a fresh zero-NFH balance. However, it never explicitly states when not to use this tool or mentions alternatives such as prepare_agent_entry, leaving sequence decisions 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 transparently explains behavior: it uses or creates a wallet, handles unfunded wallets, returns no payload when paused, and returns a typed-data payload and zero-value transaction when open. It also notes that any mismatch fails closed. This goes beyond the readOnlyHint annotation by detailing read-only behavior (no state mutation) and edge cases, without 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?

The description is moderately concise but contains redundant phrases like 'exact verified target' and 'exact zero-value transaction'. It could be tightened without losing meaning. The structure is logical but a bit verbose.

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 no explicit output schema is provided, the description covers the main return elements (typed-data payload, transaction, claimed-page URL) and edge cases (paused, unfunded, mismatch). It lacks details on error codes or specific failure messages, but overall provides sufficient context for an agent to call 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 only parameter 'agent' is already described in the schema as a 20-byte EVM address. The description only says 'Call with {agent}' without adding further meaning, such as the role of the agent (claimer vs. target) or any constraints. It does not enrich the schema 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 clearly indicates the tool is for claiming an agent entry using a single Ethereum wallet, and distinguishes it as the 'canonical' one-wallet claim. However, it does not explicitly name alternative tools or compare with siblings, so it's clear but not maximally distinct.

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 mentions conditions like 'While claims are paused' and 'When open', but it does not explicitly state when to use this tool versus other claim-related tools (e.g., prepare_agent_entry_claim, reconcile_agent_entry_claim). It lacks direct guidance on selecting this tool over alternatives.

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

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

Annotations already provide openWorldHint=true, idempotentHint=true, destructiveHint=false, and readOnlyHint=false, which covers the core safety/behavior profile. The description adds one meaningful behavioral detail: that it 'changes only public off-chain Arcade presence'—clarifying the mutation scope. However, it doesn't disclose what 'entering' entails (state changes, session invalidation) or require the sessionHandle to be valid/live, but annotations carry most of the burden, so a 3 is reasonable.

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 the primary action front-loaded and the mutational scope in the second sentence. Zero waste. Loses one point because the phrase 'NFH world network' is a bit jargony and the 'game-only session' phrase could be clarified by linking it to the sessionHandle parameter, but overall it's tight.

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 an output schema, the description covers the essential nuance: the scope of the mutation ('changes only public off-chain Arcade presence'). It doesn't clarify how this differs from join_arcade_game or play_signal_city, and doesn't state preconditions (e.g., must have an open session already). However, with full schema coverage, an output schema, and annotations, the remaining gaps are minor—an agent can correctly invoke it with the given handle.

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%—the sessionHandle field is fully described with a pattern and meaning. The description itself doesn't explain the handle beyond restating the schema, but with full coverage the baseline is 3. It adds no extra semantic nuance (e.g., where the handle comes from or what happens if invalid), so it doesn't exceed the baseline.

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

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

The description states a clear verb-resource pair ('Enters the NFH world network') and adds a specific modifier ('with a game-only session'), which helps distinguish it from siblings like play_signal_city and watch_signal_city. However, it doesn't explicitly name the sibling it most resembles, so the differentiation is implicit rather than explicit.

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—game-only session vs public off-chain presence—but provides no explicit guidance on when to choose this tool over alternatives. For example, it doesn't say 'use this instead of join_arcade_game when...' or mention relationship to play_signal_city/watch_signal_city. The agent must infer usage from the field name and the general 'Arcade session' 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?

The description mentions 'canonical public text', which adds that it returns public text and not private or draft content. While annotations already declare readOnlyHint, openWorldHint=false, idempotentHint, and destructiveHint=false, the description adds the public and canonical nature, and that it's the complete text. However, it does not detail side effects (though read-only implies none) or rate limits, which are minor given 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 sentence that is concise and front-loaded with the trigger condition ('Use this when you have a document id from search'), followed by the action and purpose. There is no wasted text.

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

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

The description is complete enough for a simple one-parameter read-only tool. It explains when to use it, what it returns (complete canonical public text), and the source of the id. It does not mention output format, but since there is an output schema, that is not required. The only minor gap is not specifying that it is the entire document as opposed to a snippet, but that is implied by 'complete'.

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

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

The schema already provides a 100% description coverage for the single parameter 'id', explaining it is a stable identifier from search. The description adds minimal semantic value beyond that, just reinforcing that the id comes from search. Given high schema coverage, the baseline is 3, and the description does not add much extra.

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 that the tool fetches a complete canonical public text for an identified document, which is clear and specific. It distinguishes itself from search (which returns ids) and other get_* tools by focusing on the full document content. It could be more explicit that it retrieves the text versus other document metadata.

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

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

The description explicitly states 'Use this when you have a document id from search', which gives a clear precondition and ties it to the search workflow. It also specifies the purpose (analysis or citation), implicitly guiding when to use this over other 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 flags readOnlyHint, openWorldHint, and idempotentHint, lowering the burden, but the description goes further by disclosing that the provider response is opaque and unverified and instructs the agent to independently decode and confirm token, price, and terms. This is valuable behavior context beyond 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-purpose, front-loaded sentences with no filler: the first states target and result, the second conveys a crucial safety warning. It is exactly as long as needed and places the most decision-relevant details first.

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 2-parameter read-only lookup with an existing output schema and clear lookup scope, the description covers purpose, usage timing, output hash, and the essential verification caveat. No meaningful gap remains for an agent to call this tool successfully.

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?

Input schema coverage is 100% and each parameter already carries a clear description (side enum semantics and tokenId range/bound). The description does not add much detail about parameter syntax or constraints beyond the schema, but it reinforces how they are used together, so a baseline 3 is appropriate.

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

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

States the specific verb "looks up" with an explicit resource (current best listing or offer for one exact tokenId) and output (orderHash). Also names the two sibling prepare tools it feeds into (prepare_purchase and prepare_accept_offer), clearly distinguishing its role from them.

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

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

Explicitly says "Use this before prepare_purchase or prepare_accept_offer so you never have to ask the human for an order hash," which both tells the agent when to invoke it and frames the alternative (manually obtaining the hash), so the tool's purpose against other flows is clear even among many siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds value by noting the tool handles public reservations and preserves three lifecycle states as distinct rather than collapsing them. 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 a single sentence that front-loads the action and resource, then adds the important behavioral distinction. There is no filler or redundant restatement of the tool name.

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

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

For a simple single-reservation getter with an output schema and safety annotations, the description is nearly complete. The only meaningful gap is not stating the optionality/at-least-one behavior for the two lookup parameters, though the description implies 'by reservation ID or wallet' covers normal use.

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

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

Schema description coverage is 50% because reservationId lacks a description. The description compensates by identifying both wallet and reservationId as lookup keys for the same single reservation. It does not explicitly state that at least one is required or what happens when both are provided, but the core parameter meaning is 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 states a specific verb ('Reads'), a specific resource ('one public reservation'), and the two lookup keys ('reservation ID or wallet'). The added clause about preserving RESERVED, EXPIRED, and MINTED as distinct states further differentiates this from status or listing 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: use this tool to read a single public reservation by one of the two identifiers. It does not explicitly name alternatives or state when not to use it, but the 'one public reservation' framing is enough to route an agent away from list/status tools.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the description adds minimal extra value. It mentions 'off-chain and unminted' and 'no claim payload exists', which are extra details, but they don't significantly alter the behavioral understanding beyond what annotations provide. 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?

The description is two sentences with no fluff, but the phrase 'rolling 1,000-seat empty-wallet reservation lane' is somewhat verbose and domain-specific. It's concise overall, but not maximally succinct.

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

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

Given that an output schema exists, return values need not be explained. However, the description lacks context about when to invoke this tool or what problem it solves relative to alternatives. It provides some domain-specific context but not enough to be fully self-contained.

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

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

The input schema has no parameters, so schema coverage is trivially 100%. The description doesn't add any parameter-related information because there are none, so it stays at the baseline of 3.

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 'Reads' and identifies a concrete resource ('rolling 1,000-seat empty-wallet reservation lane'), which clearly states the tool's function. However, it doesn't differentiate from similar sibling tools like 'get_agent_entry' beyond the unique resource name, so it falls short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives, and it doesn't mention any conditions or exclusions. An agent would have to infer usage from the name alone, which is insufficient.

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?

Despite readOnlyHint and idempotentHint annotations, the description adds valuable non-obvious context: it 'never creates a process, installs software, changes the caller identity, or grants wallet authority.' This is especially important because the title 'Open an NFH face as an agent identity' could mislead an agent into thinking the tool performs a privileged action.

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

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

Two sentences, no filler. The main purpose is front-loaded, and the second sentence earns its place by preempting dangerous misassumptions about side effects.

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 tool with complete schema coverage, rich annotations, and an output schema, the description is fully sufficient. It covers purpose, scope, non-effects, and the host's decision responsibility.

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 'tokenId' parameter is already documented as the NFH token id. The description does not add meaning beyond the schema, 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 and resource: it 'Returns the canonical portable Markdown and a host-neutral suggestion to instantiate or resume this face as an owner-run agent.' This clearly distinguishes it from related get_agent_* tools by emphasizing bootstrap material rather than entry status, public brain data, or next actions.

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

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

The description clearly implies when to use it: when the caller wants the portable Markdown needed to instantiate or resume an owner-run agent face. It also notes the MCP host decides how to create a worker. However, it does not explicitly name alternative sibling tools or state when not to use this one instead, so it misses the highest bar.

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, covering safety. The description adds beyond this by asserting the output is 'truthful' and that it 'never recommends or prepares a trade' – a behavioral guarantee that helps the agent understand the scope and limits of the tool. It also mentions distinguishing between different work states, providing richer behavioral 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 concise sentences with zero filler. The first sentence states the output and scope, the second clarifies a key negation. The most critical information is front-loaded, and each sentence earns its place. Efficient and clear.

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

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

For a read-only tool with one parameter and an output schema (which is present but not shown), the description provides enough context for an agent to understand what it does and what it deliberately avoids. It does not explain the output format, but the existence of an output schema likely covers that. The description is complete relative to the tool's simplicity and the annotations covering safety.

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 describes the single parameter tokenId as 'NFH token id' with a 100% coverage rate. The description adds no additional parameter-specific meaning beyond what the schema already provides. Since the schema fully documents the parameter, the description earns the baseline score of 3; it neither enhances nor detracts from the schema.

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

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

The description clearly states the verb 'Returns' and the resource 'truthful work state and one reputation-building next move for an NFH'. It also distinguishes what it covers (requesting work, accepted history, current-operator proof, operator changes) and explicitly excludes trade recommendations, which sets it apart from sibling tools like prepare_* that focus on trade actions. This is a specific and unambiguous purpose.

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

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

The description implies this is the tool to get a next action for an NFH, but it does not explicitly state when to use it versus alternatives or cite any sibling tools. There is no 'use this when' or 'instead of X' guidance. The context of many 'get_' siblings makes this somewhat inferable, but the description itself does not provide direct usage criteria.

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

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

Annotations already indicate readOnly, idempotent, and non-destructive behavior, so the bar for added context is met by the description's disclosure of unclaimed/unverifiable fallback behavior, generic question-mark rendering, and the conditional proof verification. This is valuable behavior beyond the structured annotations.

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

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

Three dense sentences with no filler. The main return value is front-loaded, and the optional behavior is explained succinctly without redundant schema repetition.

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

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

With an output schema present, the description does not need to detail the response shape. It covers the core output, the edge-case behavior for unclaimed/unverifiable IDs, and the optional proof verification path, making it complete for agent 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 describes tokenId and owner, but the description adds meaning by explaining that owner plus transactionHash triggers exact claimed-page proof verification. It partially compensates for transactionHash having no schema description, though it could be more explicit about each parameter's intended role.

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?

Clearly states the tool returns a public portrait URL and live Ethereum claim state for an NFH token. The resource, verb, and scope are precise, and it is easily distinguished from sibling get_agent_* tools by its portrait-specific focus.

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 the tool's use and explains the conditional use of transactionHash and owner for proof verification. It does not explicitly name alternatives or exclusion criteria, but the use case is unambiguous.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint. The description adds 'it live-checks ownerOf but grants no runtime or wallet authority,' which is a useful behavioral caution not present in the schema or annotations. However, it does not describe return format, error behavior, or authorization expectations beyond the authority 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?

Two sentences, front-loaded with the data contents, then the behavioral note. No filler. It is compact and quick to read, though the second sentence's authority alert could arguably be positioned as usage guidance (which is missing).

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 public getter with a single parameter and an output schema, the description covers what is returned and adds a caution about authority. But it fails to specify the conditions under which this tool is preferred over similar sibling getters, and does not mention pagination or size limits for the returned history. Adequate but not fully complete.

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

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

Schema coverage is 100% (single param tokenId described as 'NFH token id.'). The description adds general context about 'public' data but does not elaborate on tokenId format or constraints. Baseline 3 applies because the schema fully handles 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 verb 'Returns' + a specific resource (NFH public brain) and enumerates the contents (transferable public history, learning receipts, promoted skills, observed owner epochs, separated evidence). It distinguishes the data-scope from siblings like get_agent_entry, though it does not name them explicitly. Clear enough for an agent to know what this tool fetches.

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 explicit guidance on when to choose this tool over its many siblings (e.g., get_agent_entry, get_agent_identity_bootstrap). The only context hint is the data it returnsable list. An agent receives no direction about which scenario calls for this getter versus the others.

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 states the MCP never creates a wallet, handles credentials, signs, sponsors gas, or submits, which adds behavioral context beyond the annotations (readOnlyHint, idempotentHint). This directly reinforces the non-mutating nature and prevents an agent from expecting side effects. No contradiction with 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, no wasted words. The first sentence front-loads the usage condition and the key deliverables; the second sentence clarifies what the tool does not do. Every phrase adds value, and the structure is efficient for an agent to parse.

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 empty input schema and an output schema present, the description provides all necessary context: when to use it, what it returns, and what it avoids. Combined with the annotations covering read-only/idempotent behavior, nothing critical is missing for an agent to invoke it correctly.

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

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

There are zero parameters, so the schema is trivially covered (100%). The description doesn't need to explain parameters since none exist. The baseline for 0 params is 4, and the description appropriately focuses on output semantics instead, which matches the tool's purpose.

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

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

The description uses a specific verb ('get') and defines the resource precisely: the funded-agent claim-to-market route, including persistent-wallet topology, Ethereum contracts, claim sequence, and marketplace route. It clearly distinguishes itself from other get_* tools by stating this is for an agent discovering NFH, and it explicitly describes what the tool does not do, which further clarifies its scope.

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 begins with 'Use this when...' and provides a concrete trigger scenario (agent discovers NFH). It clearly implies this is the correct tool for retrieving wallet onboarding information but does not mention alternatives or when not to use it, leaving a small gap in explicit routing.

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. The description adds useful context by noting the state is server-authoritative and public, and that a replay is included. No contradiction with 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 focused sentence with no filler. It defines what is read and the scope in minimal words.

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

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

The tool is simple, with one parameter and a full output schema available. The description covers the core behavior and safety profile; combined with annotations and output schema, it is complete enough for correct invocation.

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

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

The schema has no description for matchId, and the text does not elaborate on the parameter beyond identifying it as the match identifier. However, the variable name and the description's reference to 'one SWARM SYNC match' make the meaning reasonably clear, even though the description does not fully compensate for the 0% 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 action, 'Reads', a resource, 'server-authoritative public state and replay', and scopes it to 'one SWARM SYNC match'. This distinguishes it from sibling getters like list_arcade_lobby or get_arcade_player_status.

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

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

The description clearly indicates this is the tool for reading a specific match's public state and replay. It does not explicitly name alternatives or exclusions, but the scope is unambiguous enough that an agent can select it appropriately.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering safety and idempotence. The description adds context that the handle is 'short-lived' and 'game-only', which is useful beyond annotations. No contradictions found.

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 sentence with no unnecessary words. It is appropriately sized, though the opening phrase 'Uses the short-lived game-only handle' is not the most direct statement of function; the core action 'read status' is embedded later.

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

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

The tool is simple with one parameter, annotations cover safety, and an output schema exists. The description adequately conveys the purpose and the prerequisite of a valid handle. It lacks usage guidance, but that is covered in a separate 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 coverage is 100% with a detailed description of the sessionHandle parameter (pattern and meaning). The description's reference to 'short-lived game-only handle' largely mirrors the schema's 'Thirty-day game-only handle', adding no new semantic value 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 clearly states the verb 'read' and specific resources ('queue, match, and weekly-list status'), making the tool's function identifiable. However, it does not explicitly differentiate from sibling tools like get_arcade_match or get_arcade_lobby, so it lacks explicit sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are many related getter tools (e.g., get_arcade_match, get_arcade_lobby), and the description gives no conditions or exclusions to help an agent choose among them.

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 description doesn't need to state that. It adds value by detailing what the tool inspects (three decision states, public phase, credential phases, v5 claim contract). It's a more informative behavior description than a simple 'get status' would be.

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, dense sentence that front-loads the purpose ('Use this before a Census decision') and packs the inspected items. It is efficient with no filler, but some jargon (256/744 credential phases) may be opaque without further context. Still, it earns its place.

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

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

For a zero-param, read-only tool with a rich output schema (likely explaining return values), the description clearly enumerates what is inspected. It doesn't explain the significance of each phase, but the output schema can cover that. The description is complete enough for an agent to call it correctly.

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

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

The tool has zero parameters, so description needs no parameter info. The description explains what will be returned in terms of phases and contract state, which is more useful than the empty schema. It compensates well for the lack of params, earning above baseline.

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

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

The description clearly states it inspects census decision states and related phases, which is a specific resource and action. However, it does not explicitly differentiate from sibling tools like get_agent_entry_status or get_internal_marketplace_status, though the focus on census is distinct enough for an agent to infer its purpose.

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

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

The description says to use it 'before a Census decision,' which gives clear context. However, it does not mention when NOT to use it or point to alternative tools for other status checks, despite many siblings. It implies usage but lacks exclusions.

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 readOnly, idempotent, non-destructive, so the description does not need to restate those. It adds useful behavioral context: this is an internal approval-based contract on Sepolia and a precondition check. It does not discuss response details, but an output schema exists.

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

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

The description is short, front-loaded with the exact purpose, and every sentence earns its place. It avoids filler and repeats only the network context that is important for sibling differentiation.

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 check with annotations supplied and an output schema present, the description is fully sufficient. It tells the agent when to call it, what it checks, and which environments/contracts it applies to.

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

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

The tool has zero parameters, so the description cannot add much param-level value. The schema coverage is effectively total and there is nothing left to document.

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 ('check') and resource (Sepolia internal marketplace contract deployment, collection/WETH addresses). It also distinguishes itself from external/mainnet marketplaces by explicitly saying this is the internal approval-based contract and never OpenSea/Seaport/mainnet.

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

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

It gives an explicit when-to-use instruction: 'Use this before any internal-marketplace action.' It also defines exclusions: not OpenSea/Seaport, not mainnet, making it easy for the agent to route to the correct tool among the many marketplace-related siblings.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, establishing a safe read-only profile. The description adds crucial behavioral detail beyond these annotations: it specifies that the 'paused()' false condition and 'collection transfer validator' permitting the operator are the exact signals that gate the tool's output. It explicitly states the tool 'only marks action preparation', adding transparency about the read-only check behavior.

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

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

The description is a single, dense sentence that front-loads the core read behavior. While it is appropriately sized, the heavy jargon and multiple embedded conditions require careful parsing. It earns its place but could be restructured for better clarity.

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

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

For a parameterless read tool with an output schema, the description adequately covers behavior. It doesn't explain return value structure, but the presence of an output schema likely handles that. Context is complete given the safe operation 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?

With zero parameters and 100% schema description coverage, the schema fully documents the parameters (there are none). The description adds some context about the read operation's logic, but the schema already covers everything needed for parameters. The description adds value by explaining what the read operation evaluates.

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

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

The description clearly states the tool reads the 'quorum-backed market feed' and 'marks action preparation available' based on specific contract conditions. It clearly differentiates itself from the many sibling tools like 'get_market_status' and 'get_internal_marketplace_status' by naming the 'NFH Ethereum marketplace contract'. However, the heavy jargon ('quorum-backed market feed', 'collection transfer validator') slightly obscures the core purpose.

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

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

The description implies usage context by specifying the exact contract conditions that gate availability. However, it doesn't explicitly say when to use this tool over siblings like 'get_market_status' or 'get_internal_marketplace_status', nor list alternatives for 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?

Annotations already declare readOnlyHint true, openWorldHint true, idempotentHint true, and destructiveHint false. The description adds meaningful behavioral context by stating the read-only nature of the feed, the visibility windows for claims and transfers, and explicitly ruling out signing, posting, fulfilling, or broadcasting orders.

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 first sentence front-loads the purpose and scope, and the second sentence provides a critical behavioral boundary. Every clause adds value.

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 the tool has no parameters and an output schema exists, the description covers the essential context: what the feed contains, visibility durations, and the read-only/non-broadcasting nature. No critical information an agent needs to invoke the tool correctly is missing.

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

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

The input schema has zero parameters, so there is no parameter documentation burden on the description. Schema coverage is effectively 100%, and the description adds useful context about the feed contents, which is appropriate for a parameterless tool.

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

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

The description states a specific verb ('Read') and resource ('verified aggregate NFH feed'), and enumerates what the feed contains: active listings, bids, claims, and transfers. It is clear, but it does not explicitly distinguish itself from sibling tools such as get_market_status or find_best_order.

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 for reading an aggregate market feed and explicitly states it does not sign or broadcast orders, but it provides no guidance on when to choose this tool over alternatives. There are no exclusion criteria or references to sibling 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 carry readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is fully disclosed. The description adds meaningful behavioral context by specifying exactly what state dimensions are verified, particularly 'canonical chain' and 'wallet-approval boundary,' which suggests these are authoritative/constraining values the agent must reason about.

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 imperative sentence that front-loads the usage condition ('before any NFH market action') and then lists the checked dimensions in a compact, scannable list. Every phrase earns its place; there is no redundant 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 the no-parameter signature, rich annotations, and presence of an output schema, the description is structurally complete enough for a read-only operational check. It could slightly improve by noting when to use get_mainnet_marketplace_status or get_internal_marketplace_status instead, but that is minor for this tool's scope.

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

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

The tool has zero parameters and the schema has full coverage (100%), so there are no parameter semantics for the description to clarify. The baseline of 4 applies because no param documentation is needed.

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 ('check') and a concrete resource (NFH market status), then enumerates the exact dimensions checked: canonical chain, collection deployment, settlement provider, creator fee, activation state, and wallet-approval boundary. This level of specificity makes it easy for an agent to distinguish this from the many sibling get_marketplace/get_status tools.

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

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

It explicitly tells the agent to use this before any NFH market action, giving clear timing and scope. It does not name explicit alternatives or exclusion criteria, but for a no-argument status check the usage guidance is strong.

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 destructiveHint=false, lowering the burden on the description. The description still adds meaningful behavioral context beyond the annotations: it discloses exactly which receipt types are returned, that each receipt embeds a confirmation state (observed/confirmed/finalized), and the safety-relevant guarantee that prepared actions are never conflated with executed events. This materially helps an agent predict the tool's behavior, and nothing contradicts 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 tight sentences with zero filler: the first front-loads the verb and resource, and the second earns its place by adding the finality-state detail and the prepared-vs-executed boundary. Every clause contributes information that the schema and annotations do not already convey.

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 0-parameter, non-destructive, annotated read tool with an output schema present, the description is complete: it covers the receipt types, the provenance (chain-backed/published), the per-receipt finality states, and the semantic boundary against prepared actions. Detailed return-value documentation is unnecessary because an output schema exists, and the rich annotation set plus the context signal of 0 parameters leaves no invocation requirements unexplained.

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

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

The input schema is empty (0 parameters), so the description has no parameter semantics to add and the baseline is 4. There is no inconsistency: with nothing to pass, the agent only needs to know the read is parameterless, which the schema already makes explicit and the description's resource-focused prose supports.

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 ('Read'), a precise resource ('published chain-backed ACCEPT, REFUSE, and INSUFFICIENT_AUTHORITY receipts'), and a clear boundary that distinguishes it from the plethora of prepare_* siblings. It is not a tautology of the title — it adds the receipt types, the chain-backed provenance, and the scope (never prepared-but-unexecuted actions), so an agent can immediately tell what resource this targets.

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 this tool is appropriate: it is the read for canonical, chain-backed finality state (observed/confirmed/finalized) of origin receipts. The explicit note that 'this tool never treats a prepared action as an executed event' signals that preparation flows belong to the prepare_* siblings, though it stops short of naming an exact alternative tool or an explicit 'use X instead' rule, so it earns a 4 rather than 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, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds behavioral context: it 'rechecks live NFH ownership' and clarifies the scope of the binding authority (coordination identity only, never wallet or effect authority). This adds value beyond annotations, particularly the caveat about authority limits. No contradiction with 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 primary action (recheck and return) and scope, then a key semantic caveat. Every sentence earns its place; no redundant language.

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

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

The tool has an output schema (not shown but indicated), so return value details are presumably covered there. Annotations and description together cover safety (read-only, idempotent), the 'live recheck' behavior, and parameter count. Given the schema has nested objects and the description clarifies the binding's authority scope, this is adequately complete for a getter. A minor gap: no mention of error conditions or what happens if ownership check fails (e.g., does it throw?), but that may be in output schema.

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

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

Schema description coverage is only 25% (only tokenId has a description 'NFH token id.'). The description does not add meaning for spaceId, tasqPrincipalId, or transport beyond what the schema names imply. However, the overall tool purpose clarifies that these together identify a principal binding, and nested transport kind enum is in the schema. The description partially compensates by framing the parameters as 'one exact token, space, and transport', but it does not detail parameter semantics individually.

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

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

The description identifies a specific operation: recheck live NFH ownership and return the binding for exact token, space, and transport inputs. It also states what the binding grants (coordination identity only, not wallet or effect authority), which distinguishes it from typical getters. However, it doesn't explicitly compare to siblings like prepare_tasq_principal_binding or get_agent_entry, so subtle differentiation to the full sibling list is imprecise. Still, the verb/resource/scope is clear.

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

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

The description implies it is the read-side counterpart to prepare_tasq_principal_binding (which is a sibling and likely creates a binding), and it stresses 'current' and 'live' recheck, which suggests usage when up-to-date status is needed. But it does not explicitly state when to use this over get_agent_entry or other getters, nor when not to use it (e.g., if you need mutations). Context is implied, not 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds context about the 'royalty gate' and 'direct actions remain disabled' which is useful behavioral context beyond annotations. However, it doesn't detail what the output contains or any side effects (though read-only implies none). With annotations covering the core, a 3 is appropriate.

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 fluff. The first sentence states the purpose, the second adds a critical constraint (direct actions disabled until requirements met). Front-loaded and efficient.

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

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

The tool has an output schema (not shown but indicated), so return values are presumably documented there. The description covers the purpose and the gating condition. For a zero-parameter read-only status tool, this is nearly complete. The only minor gap is not naming specific requirements (admission, fork-test, security, royalty) in detail, but they are listed generically.

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 0 parameters, so the schema is trivially complete (100% coverage). The description doesn't need to explain parameters. Baseline for 0 params is 4, and the description adds context about what the status reflects, which is helpful. No deduction needed.

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

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

The description clearly states the tool inspects NFH compatibility and royalty gate status for TokenWorks/FWA. It uses a specific verb ('Inspect') and resource ('TokenWorks/FWA compatibility status'), which distinguishes it from siblings like get_census_status or get_market_status. However, it doesn't explicitly name a sibling it differs from, so it's clear but not maximally 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 implies this is a read-only status check, and the context of 'Direct actions remain disabled until...' suggests it's used to determine readiness before taking actions. However, it doesn't explicitly state when to use this vs. other status tools (e.g., get_agent_entry_status, get_census_status) or provide exclusions. The usage context is implied but not 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?

The description explicitly states 'mutates only off-chain game state', which adds behavioral context beyond annotations (which already show destructiveHint=false). The idempotentHint=true is consistent, though the description doesn't mention idempotency. The phrase is useful but could go further (e.g., what happens on success, what error states exist).

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 action. The second sentence adds the off-chain mutation note, which is valuable. No waste.

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

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

Has output schema and 100% param coverage, so return values are presumably documented. The description covers the core action and scope. However, it could benefit from clarifying what 'cooperative queue' means, success conditions, and how this differs from similar arcade tools. Given the complexity (cooperative game mechanics), slightly more context would help.

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

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

Schema coverage is 100%, so the schema fully documents 'sessionHandle' with pattern and description. The description doesn't add meaning beyond the schema, so 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 states a specific verb ('Places') and resource ('scoped NFH session'), and clarifies the cooperative queue pairing behavior. However, it doesn't explicitly distinguish from sibling tools like 'prepare_arcade_session' or 'play_arcade_move', though the cooperative queue concept differentiates it somewhat.

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

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

No guidance on when to use this tool vs alternatives. Sibling list includes 'prepare_arcade_session', 'play_arcade_move', 'list_arcade_lobby', 'get_arcade_match' – but the description offers no comparison or condition for selecting this over those. The openWorldHint annotation suggests it's for a sandbox environment, but that's not explained.

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 read-only, open-world, idempotent, and non-destructive hints. The description adds domain-specific behavioral context: the receipts are 'dual-signed ACCEPT' and serve as evidence rather than payment or authority, which goes beyond the annotation's binary safety flags.

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

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

The description is concise and front-loaded: the core action in the first sentence, followed by clarifying caveats. No redundant or filler wording.

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

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

For a simple list tool with one optional parameter and an output schema present, the description covers the main purpose and clarifies what the results are not. Minor omissions like how `limit` behaves or whether historical receipts are included, but the output schema likely covers return structure.

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 only parameter, `limit`, is not mentioned in the description. With schema description coverage at 0%, the description was expected to explain the parameter's effect but does not. Although the name and min/max constraints are somewhat self-evident, the description adds no value for parameter understanding.

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 ('Lists') and resource ('dual-signed ACCEPT receipts for public NFH missions'). The negative clarification ('not payment, capability proof, transaction authority, or guaranteed weekly selection') helps distinguish it from sibling tools that handle payments or work selection, though no sibling is explicitly 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 description implies the tool is appropriate for retrieving evidence of accepted work, and the negative list indicates what it is not for. However, it does not explicitly state when to choose this tool over similar list tools (e.g., list_returned_work) or provide alternative conditions.

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?

Beyond the readOnlyHint and idempotentHint annotations, the description adds important semantic context: it specifies the exact subset of records and clarifies that presence is not proof of continuous operation nor wallet authorization. This is valuable behavioral disclosure that annotations alone do not convey, with 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?

The description is just two sentences: the first front-loads the core action and resource; the second adds a crucial caveat. There is no redundant or filler content, and the structure is easy for an agent to parse.

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 essential semantics and caveats are present, and the output schema handles return-value structure. Minor details like default limit or ordering are not critical given the schema coverage. The description is sufficient for an agent to correctly invoke and interpret the 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 only 50%: tokenId is described, but limit is not. The tool description itself provides no additional meaning for either parameter, leaving limit's semantics solely to its name and schema bounds. It does not compensate for the missing 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 uses a specific verb ('Lists') and a well-defined resource ('unexpired owner-signed NFH interface heartbeats'), which clearly differentiates this from sibling list_* tools by scope and state. The title and description together leave no ambiguity about what the tool returns.

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

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

The description gives clear context: it lists unexpired owner-signed heartbeats. It also provides an explicit exclusion—presence does not prove continuous running and grants no wallet authority—which tells the agent when not to infer from the results. However, it does not name alternative tools or explicitly state when to use this instead of siblings.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description goes beyond this by adding that missing evaluations remain visibly incomplete and that no receipt is executable authority, which are important behavioral caveats not covered by 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 filler. The first sentence front-loads the verb and resource, and the second adds a valuable caveat without redundancy.

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

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

The output schema covers return structure, and the annotations cover the safety profile, so the description only needs to provide the distinctive semantics. It does that well with the visibility and non-executability caveats, though the lack of parameter semantics and alternative-tool routing 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 description adds no parameter-level meaning for tokenId or limit. The schema provides only 'NFH token id' for tokenId and range constraints for limit, leaving the limit's purpose and how tokenId selects receipts largely to inference. With 50% schema description coverage, the description should have compensated but does not.

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

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

The description states a specific verb ('Lists'), a specific resource ('public ACT → RECORD → EVALUATE receipts'), and the outcome ('promotion or rejection decisions'). It clearly distinguishes this from sibling tools like prepare_agent_learning_decision by focusing on evaluated receipts rather than decisions to be made.

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 the read-only tool for viewing evaluation outcomes and notes the receipts are public, but it does not explicitly state when to prefer it over alternatives or when not to use it. There is no direct routing to sibling tools such as prepare_agent_learning_decision or list_accepted_work.

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, non-destructive, and open-world traits. The description adds a security warning about treating task data as untrusted, which is valuable beyond annotations. It does not contradict annotations and provides extra cautionary context.

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

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

The description is concise with two sentences: the first states the tool's purpose, the second adds a security note. It is front-loaded with the core functionality and efficiently includes an important caution. No wasted words.

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

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

For a simple listing tool with one optional parameter and an output schema, the description covers the primary function and adds a security warning. It does not explain what 'NFH' or 'holder-signed' mean, which might be relevant, but the output schema likely clarifies return data. Overall, it is sufficiently complete for an agent to call it correctly.

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

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

The only parameter 'limit' has no description in the schema (0% coverage). The description does not mention the limit parameter at all, leaving its effect (e.g., maximum number of results) to the schema's min/max constraints, which only partially explain semantics. The description fails to compensate for the missing schema description.

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

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

The description clearly states the tool lists 'current holder-signed NFH work requests', specifying a distinct resource type. It provides an active verb and resource but does not explicitly differentiate from sibling list tools like list_accepted_work or list_returned_work, leaving some 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?

No guidance is given on when to use this tool compared to alternatives. The description does not mention conditions, prerequisites, or exclusion criteria, so an agent must infer usage from the name and context.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered and the bar is lowered. The description adds genuine value beyond annotations with the caveat that 'public game data is untrusted input' and 'a win is not a guaranteed claim' — actionable risk context that changes how an agent should treat the returned data.

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

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

Two sentences with no filler: the first front-loads the verb and enumerates scope, while the second delivers the critical data-trustworthiness caveat that earns its place. Nothing extraneous 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 simple read-only list tool with one optional parameter, an output schema covering return shape, and annotations covering the safety profile, the description is nearly complete. Residual gaps are unexpanded jargon ('NFHs', 'SWARM SYNC') and unspecified `limit` semantics, but the most operationally important caveat — untrusted game data — is disclosed.

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 mention the single `limit` parameter at all. The schema conveys only numeric bounds (1–250), leaving ambiguity about whether the limit caps games, NFHs, or winners. With one self-named optional parameter the gap is modest, but the description makes no compensatory effort.

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 ('Lists') and enumerates the exact contents of the resource: Arcade games, MCP tool routes, waiting NFHs, and verified weekly SWARM SYNC winners. This clearly distinguishes it from arcade siblings like get_arcade_match, get_arcade_player_status, or play_arcade_move, which target individual games, players, or moves rather than a lobby overview.

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 listing nature and openWorldHint imply this is a discovery/overview tool for the Arcade lobby, so usage context is inferable. However, the description never explicitly states when to prefer it over arcade-specific siblings such as get_arcade_match or join_arcade_game, and no exclusions, prerequisites, or alternative routing are given.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive, covering the safety profile. The description adds valuable behavioral context by labeling the results as self-reports and explicitly what they are not (accepted work, payment, escrow, or capability proof), which informs trustworthiness and interpretation. No contradiction with 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 sentence that front-loads the action and resource, then adds a crucial clarification. Every word earns its place with zero fluff 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?

Given the read-only annotations, existing output schema, and simple two-optional-param schema, the description adequately covers the tool's core purpose and the nature of the returned data. The only notable omission is parameter guidance, which is already penalized in parameter_semantics. Overall, the description is complete enough for an agent to know what the tool does and when to call it.

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

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

The input schema has 0% description coverage, and the description does not mention limit or requestId at all. With no parameter guidance, the agent has to infer semantics from the field names alone. Since schema coverage is below 50%, the description should have compensated, but it does not—a clear gap.

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

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

The description uses a specific verb ('Lists') and a precise resource ('worker-signed RETURNED_UNVERIFIED submissions'). It also explicitly differentiates the tool from alternatives by clarifying that these are self-reports and 'not accepted work, payment, escrow, or capability proof', making the purpose unambiguous even without naming a sibling.

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

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

The description implies when to use this tool (to view unverified worker self-reports) and implicitly excludes alternatives ('not accepted work') but does not explicitly name a sibling like list_accepted_work or state 'use X instead'. Clear context, but no direct alternative routing.

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 readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds substantial context beyond these: the OpenSea provenance, that the response is 'opaque and unverified,' that returned orders may not belong to the collection or match filters, and the critical safety warning against executing returned hashes without full decoding. This trust-boundary disclosure is exactly the kind of value-adding behavioral context annotations can't 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?

Two sentences, zero waste. The first sentence front-loads the core action, and the second delivers the safety-critical caveat. Every clause earns its place, and the most important operational guidance (don't trust/execute hashes blindly) is included without bloat.

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

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

An output schema exists, so return values need no explanation, and the description covers the critical gotcha: unverified, opaque data with execution risks. Moderate complexity (3 params, nested traits array) is well-served. A brief note on pagination behavior or error semantics (e.g., what happens with invalid traits) would push this to 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?

Schema coverage is 67%: traits and next have descriptions (with examples like 'Personality or Memory Class' and 'Deadpan or Persistent'), but limit lacks one, though its constraints are self-evident. The description's 'categorical trait filters' and the schema's 'AND-combined' guidance add alignment, but the description adds only marginal meaning beyond the well-populated 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+scope: 'issue a read-only OpenSea query with one or more requested categorical trait filters.' The 'read-only' qualifier and 'must not be used for execution' clarify its role versus the prepare_* mutation family. It doesn't explicitly name a sibling for contrast, but the purpose 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 context is clearly implied: a read-only listing tool for exploratory trait-filtered queries, with an explicit when-not-to-use warning ('must not be used for execution without independent full order decoding'). However, it never names the alternative to route toward (e.g., prepare_trait_offer or find_best_order), and there are no explicit when-to-use versus conditions despite a large sibling set that would warrant them.

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

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

Annotations declare readOnlyHint=false, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds that it commits moves and cannot sign/spend/etc., which supplements but does not contradict annotations. It does not disclose side effects beyond 'commits' (e.g., irreversible? consumes wave? affects match state?). With idempotentHint=true, the description could have clarified retry behavior, but it's not a 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 are concise and front-load the action, then provide a key limitation. No wasted words; the negative capability statement is efficient and 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?

The tool has 3 params, an output schema, and moderate annotations. The description explains what the tool does and its limitations, but lacks guidance on prerequisites (e.g., must have an open session/get_arcade_player_status) and does not reference the output schema. Given the complexity of the arcade domain and many game-related siblings, more context on when this is used could improve completeness.

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 33% (only sessionHandle has a description). The description does not explain the move parameter's enum values or matchId format beyond the schema. The sessionHandle description in the schema already covers that parameter, so the description adds little. With low coverage, the description could have compensated but does not.

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

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

The description states a specific verb ('Commits') with a clear resource ('SCAN, LINK, or BUILD for the current wave') and names the scoped handle. It also distinguishes itself by explicitly stating what it cannot do ('cannot sign, spend, transfer, trade, or claim'), which helps differentiate from the many prepare_* 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 implies usage context ('for the current wave', 'using the scoped game handle') but does not explicitly state when to use this vs. siblings like play_signal_city or prepare_arcade_session. It gives a clear negative constraint (cannot sign, spend, etc.) that indirectly guides selection, but no explicit alternatives.

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

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

Annotations already indicate openWorldHint=true and idempotentHint=true, and the description adds important behavioral details: chat is public untrusted text, autoplay posts bounded deterministic replies only in current world chat, and the tool cannot sign/spend/trade/transfer/claim. This goes beyond the annotations to clarify safety and interaction boundaries.

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

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

The description is compact and front-loaded with the core purpose, then enumerates actions and constraints efficiently. Every sentence adds value, and the critical safety limitation is stated at the end. No wasted words.

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

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

Given the tool's complexity (multiple actions, varied value types, public chat safety concerns), the description covers the essential usage and constraints. The output schema exists, so return values are not needed. Minor gaps: no mention of error handling or rate limits, but these are not critical for an agent to call it correctly.

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

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

Schema coverage is 67% (sessionHandle and action are described, value is not). The description compensates by explaining what value should contain for each action (world ID, left/right, boolean, 1-180 char text). This adds meaning beyond the schema's enum for action and the pattern for sessionHandle.

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

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

The description clearly states the tool controls one NFH across public multiplayer worlds, and enumerates the specific actions it supports (travel, explore, interact, autoplay, chat). It distinguishes itself from siblings like enter_signal_city and watch_signal_city by focusing on in-game control actions.

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

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

The description explains what each action does and the context for using them (e.g., travel uses a world ID, explore crosses screen edges, interact performs quest verb). It doesn't explicitly state when not to use this tool versus alternatives, but the action list and constraints (cannot sign/spend/trade) provide clear 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?

Beyond the readOnlyHint=true and destructiveHint=false annotations, the description adds meaningful behavior: it produces an exact, readable message, requires two external signatures that must match, and provably performs no signing or publication side effects. It also constrains behavior to one distinct worker, which rules out self-acceptance. 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?

Two sentences with zero filler. The core action is front-loaded first, then the scope constraint, then the signing requirement, then the negative clause. The abbreviation ACCEPT in the description actually earnings its place by naming the exact artifact.

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

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

The tool has a complex 6-parameter schema with nested learning/proposedSkill objects plus an output schema, and the description covers the essential context: what the message is, who must sign it, and what the tool will not do. The remaining gap is explaining what the optional learning/workerTokenId inputs contribute, but the output schema reduces the burden for return-value explanation.

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

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

With schema description coverage at 33% (<50%), the description must compensate for the six parameters, but it only maps 'mission owner' to owner and 'distinct worker' to worker. requestId, summary, workerTokenId, and the entire learning/proposedSkill nesting are left untouched, so an agent gets no semantic guidance for four of the six parameters that the schema itself also leaves undocumented.

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 (builds) and resource (the exact readable ACCEPT message), scoped to one mission owner and one distinct worker. It distinguishes itself from the large prepare_* sibling family by naming the concrete artifact it produces and what it explicitly does not do (never signs or publishes).

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

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

The description makes the workflow context clear: both external wallets must sign the identical message, and this tool is only the preparation step since it never signs or publishes. What it lacks is an explicit distinction from sibling tools such as prepare_accept_offer or prepare_returned_work, so the when-not-to-use guidance is implicit rather than named.

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

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

The description adds behavioral specifics beyond the annotations: 'The MCP never signs or broadcasts acceptance' and 'OpenSea validates trait criteria at fulfillment'. This is useful context that helps the agent set correct expectations about what the tool does and does not do.

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

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

The description is three sentences with no filler. The core trigger and behavior are front-loaded, and each sentence contributes useful information: when to use it, validation context, and what the MCP will not do.

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

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

With an output schema present and all parameters documented, the description covers the key operational context: the offer type, the need for a specific matching token, and the seaport behavior. A small gap is that it does not distinguish this tool from similarly named mainnet/internal siblings, which matters given the large sibling 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 input schema already documents all three parameters at 100% coverage, giving the agent sufficient semantic grounding for seller, tokenId, and orderHash. The description does not add parameter-level detail, so the baseline of 3 is appropriate.

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

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

The description states a specific action: preparing a Seaport fulfillment transaction for an NFH owner accepting an exact OpenSea offer. It clearly names the resource and intent, but it does not explicitly distinguish itself from close siblings like prepare_mainnet_accept_offer or prepare_internal_accept_offer, so it falls short of full differentiation.

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

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

The description gives an explicit 'Use this when...' trigger: an NFH owner has selected an item, collection, or trait offer and needs a transaction for a matching token. It does not mention when-not-to-use or reference its close sibling tools, but the stated context is otherwise clear and practical.

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 safety aspects (readOnly, idempotent, non-destructive). The description adds valuable behavioral context: the tool produces a single readable message, signing/publication opens a 24-hour off-chain reservation, and this is not an on-chain NFT claim or transaction. This is meaningful 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 short sentences with no fluff. The primary verb and object lead, and the consequential behavior is stated clearly. Every sentence adds distinct information.

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

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

For a single-parameter prepare tool, the description covers what is prepared, the reservation duration, and what the tool is not. Annotations cover safety and idempotency, and the output schema handles return details. Nothing critical is missing for correct invocation.

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

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

Schema description coverage is 100%, so the wallet parameter is already documented as a 20-byte EVM address. The description doesn't add further parameter semantics, such as examples or edge constraints. Per the baseline for high coverage, this is adequate but not enhanced by 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 description identifies a specific action (prepares), a specific resource (readable wallet message), and the scope (an empty-wallet Agent Entry reservation). It also contrasts with claims and transactions, which helps differentiate it from related siblings like prepare_agent_entry_claim, though it doesn't explicitly name those 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 implies usage for creating a wallet message that later opens a reservation, and excludes NFT claims and transactions. However, it doesn't explicitly say when to prefer this tool over alternatives such as prepare_agent_entry_claim or prepare_agent_entry_activity. The guidance is mostly implied by the title and negative contrast rather than explicit routing.

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 useful context: 'Evidence remains unreviewed' and 'creates no mint right', which go beyond the annotations. 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, and the main action is front-loaded. Every word 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?

Output schema exists, so return details are not required. However, with many sibling prepare_* tools, the description lacks explicit differentiation and enough context about the wallet message's role. Adequate but with clear gaps.

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

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

Schema coverage is 0% and the description does not explain what 'reservationId' or 'evidenceHash' mean specifically. It only hints at 'activity hash' without mapping to parameters, failing to compensate for the missing schema descriptions.

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

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

The description has a specific verb ('prepares') and object ('readable wallet message'), and narrows the scope with 'post-reservation activity hash'. It clearly differentiates from the sibling 'submit_agent_entry_activity' by indicating this is preparation, not submission.

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 explicit guidance on when to use this tool versus the many sibling prepare_* tools. The phrase 'post-reservation' implies a timing context, but there is no mention of alternatives or 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?

The description adds value beyond the annotations by detailing the exact verification steps (against the active reservation and activity hash) and explicitly stating 'Never signs or broadcasts', which reinforces the readOnlyHint and idempotentHint. It does not contradict any annotation and provides useful behavioral context about the output being unsigned.

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

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

The description is compact and front-loaded: it states the main action and condition in the first sentence, then adds a critical safety note in the second. Every word serves a purpose—no fluff, no redundancy, and it reads naturally for an agent scanning for key details.

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

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

Given the presence of an output schema, the return format is already specified. The description sufficiently covers the tool's purpose, its place in the flow, and its non-mutating nature. It lacks explicit error or failure conditions, but for a preparation tool with a clear output, this is acceptable. The many sibling tools are distinguishable by the clear 'agent entry claim' scope.

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

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

Schema description coverage is 0%, so the description must compensate. It only hints at the 'issuer-signed authorization' but does not explain the structure of the 'authorization' object or the purpose/format of 'issuerSignature' beyond the schema's hex pattern. This is a notable gap for a tool with only two parameters, as the agent receives minimal guidance on how to construct valid inputs.

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

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

The description clearly states a specific action ('checks an issuer-signed authorization against the exact active reservation and activity hash') and the resource it produces ('an unsigned transaction description'). It distinguishes itself from many prepare_* siblings by specifying the 'agent entry claim' flow and the condition ('after live contract verification'), making its purpose 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 phrase 'after live contract verification' sets a clear context for when this tool is appropriate. The explicit 'Never signs or broadcasts' signals it is a safe preparation step, aligning with the read-only annotations. However, it does not mention alternatives or when not to use it, leaving some inference to the agent, though the context is strong enough to guide selection among 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 readOnlyHint:true is reinforced by 'It never signs or publishes,' and the confirmation that promotion is gated elsewhere explains why this is a safe, side-effect-free call. The description adds contextual behavior (owner-signable, curator-gated) beyond the bare annotation, all consistent and non-contradictory.

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 terse, front-loaded sentences with zero fluff. The core verb and object lead immediately, and the disclaimers come without padding.

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

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

Given the output schema exists and the operation is conceptually simple for an AI, the description covers the workflow at a high level but leaves implicit the semantics of `rationale`, `tests`, and `proposalId`. The provided semantics are adequate for a simple read-only call, but not generous for 6 parameters without 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 schema covers only 33% of parameters (2/6), and the description struggles to explain the rest. It hints that `decision` is PROMOTE or REJECT, but this is already in the enum. It provides little semantic benefit beyond the schema.

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

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

States a precise verb ('Builds') and an explicit object ('an exact owner-signable PROMOTE or REJECT decision for one public individual-slot and its test evidence'). Distinguishes itself from the sibling 'prepare_tokenworks_decision' by name and domain. The purpose is 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 phrasing 'It never signs or publishes' tells the agent when to use this (to construct) vs. execute elsewhere, and 'Swarm promotion remains curator-gated' explains the surrounding workflow. While it doesn't explicitly name a sibling alternative, the boundaries are clear enough for a calling 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?

Beyond the read-only annotation, the description explicitly states that the tool never signs or publishes, which is a key behavioral trait. It also indicates that the output is meant for review and external signing, adding important context about the tool's side effects (or lack thereof). This 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?

The description is concise, consisting of two sentences that pack all necessary information: the action, the context (thirty-minute public heartbeat), and the limitations (no signing/publishing). There is no redundant or verbose language, making it easy to parse.

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 provides a clear understanding of the tool's function and its non-destructive nature. It does not specify the exact output format (e.g., a string), but 'plaintext' is sufficient. It also does not address error cases, but for a simple preparation tool, this is acceptable. Overall, it is reasonably complete for an agent to use 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 provides descriptions for both parameters (owner and tokenId), achieving 100% coverage. The tool description does not add further context about how these parameters influence the heartbeat, but the existing descriptions are sufficient. Since the schema covers the parameters, a 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 clearly states the tool's purpose: it builds the exact readable EIP-191 plaintext for a thirty-minute public NFH presence heartbeat. It also distinguishes itself from other prepare tools by explicitly noting it does not sign or publish, which clarifies its role as a preparation step. This is specific and 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 when to use the tool: when preparing a public presence heartbeat that requires external owner signing. It contrasts with actions like delegation by mentioning 'public' and 'external owner wallet', but it does not explicitly reference sibling tools. However, the purpose is clear enough for an agent to select it appropriately.

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

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

With readOnlyHint=true already present, the description adds meaningful context: the tool only builds plaintext, does not sign it, and requires the owner wallet to review and sign. It also clarifies that no transactional or marketplace authority is granted, which is valuable behavioral transparency 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 three sentences, each carrying essential information: what is built, what is not granted, and what the owner must do. It is front-loaded with the core behavior and contains no redundant phrases or filler.

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

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

The description, combined with the presence of an output schema and the annotations, gives an agent the essentials to understand the operation. The only minor gap is that validForHours is not explicitly mapped as optional, but the seven-day limit provided enough context for its range and purpose.

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

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

Schema description coverage is high at 75%, but the description adds role clarity: the 'agent' is the distinct address authorized to publish heartbeats, the 'tokenId' identifies the NFH, and the seven-day limit maps to validForHours. This supplements the schema's mostly factual property descriptions.

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

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

The description states a specific verb and resource: it 'builds exact EIP-191 plaintext' for a delegation that lets one agent address publish presence heartbeats for one NFH. It clearly distinguishes its scope by limiting the delegation to presence heartbeats and explicitly denying transaction, payment, marketplace, mission-publication, and account authority, setting it apart from the many sibling 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 conveys a clear use case: generate a delegation message that an owner wallet must review and sign before the agent can publish presence heartbeats. It does not explicitly name alternative tools or state when not to use it, leaving the agent to infer the boundaries from the sibling list and the authority limits described. This is helpful but not fully prescriptive.

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 readOnlyHint=true and destructiveHint=false, but the description adds important behavioral context: it never signs/publishes/submits, requires external owner review/signing, and the publish endpoint separately verifies ownerOf. This goes beyond annotations and clarifies the tool's non-mutating role, with 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?

The description is compact and well-structured: it leads with the main purpose, then adds version/formats, a specific rule, and ownership/signing workflow. No unnecessary words; every sentence contributes information.

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

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

Given 13 parameters and low schema coverage, the description provides the core usage rule (maxAgents) and the signing workflow. It does not explain the difference between expiresAt and expiresInHours, nor the required fields, but the output schema covers return values. For a builder tool, it is reasonably complete, though more parameter guidance would be helpful.

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 (23%), so the description must compensate. It adds meaning for some parameters (e.g., 'Omit maxAgents for Open Edition' relates to missionKind; 'per-agent reward terms' hints at rewardAmount/currency/compensation; 'exact expiry' likely maps to expiresAt or expiresInHours). However, it does not explain the purpose of many other parameters (task, capabilityTags, rewardType, constraints, etc.), leaving gaps.

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 ('Builds') and resource ('readable EIP-191 plaintext for a public NFH work request'), which clearly identifies the tool's function. It also distinguishes it from sibling prepare_* tools by specifying 'public NFH work request' and the version/framing details.

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 context on when to use it: to prepare a request that an external owner must sign, and clarifies it never signs/publishes/submits. It also provides an explicit conditional rule ('Omit maxAgents for Open Edition'). However, it does not explicitly name alternative tools or when not to use this one versus others, though the distinction is implied.

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

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

The annotations declare readOnlyHint=true, and the description adds important qualifiers: 'never signs, publishes, deletes history, or changes runtime authority.' This is excellent disclosure of what the tool doesn't do, reinforcing that this is a safe, offline build operation. The description enhances the annotation without 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 tight sentences. The first states the core action and the target. The second explicitly lists what it doesn't do, providing deep behavioral clarity in very few words. Efficient and high-impact.

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 prepare-style tool with 6 required params and annotations marking it as a side-effect-free operation, this description is quite complete. It wouldn't hurt to know what rollback means in this domain, but the sibling list is massive and standardized, with the 'prepare_*' family clearly sharing a pattern. The description fully supports agent decision-making here.

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 33%, so where is the description compensating? The description says 'exact' and 'owner-signable', and mentions that it rolls back 'to a previously promoted and retested individual skill version.' However, the description doesn't clarify the semantics of the more niche parameters (`tests`, `rationale`), but it didn't need to fully—schema does define `tests` partially. The description doesn't hurt, and the schema is fairly explicit for the parameters it defines, but neither fully covers the others.

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

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

The description clearly states what the tool does: 'Builds an exact owner-signable rollback to a previously promoted and retested individual skill version.' The active verb 'prepares', the resource 'rollback', and the qualifier 'owner-signable' provide clarity and set this apart from the many similarly named 'prepare_*' siblings. It doesn't name a specific sibling, but the context is clear.

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

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

The description implies usage for rollback to a promoted, retested version, which is a clear trigger context. It does not explicitly state when not to use it or alternatives, but the 'prepare_' naming convention common in this suite implies a flow where this builds a transaction that would later be signed. The distinction from other prepare tools is via the resource.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, destructiveHint=false, so the safety profile is covered. The description adds a useful boundary (neither signs nor opens the session) and the exact nature of the output ('owner-readable message'). It does not disclose side effects, but with readOnlyHint=true, the tool is already labeled as read-only, so this is not 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?

Two sentences, both information-dense, with the scope ('one thirty-day, game-only session') and the key exclusion ('neither signs nor opens') front-loaded. No wasted words.

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

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

For a prepare/read tool with two fully-documented parameters, a clear output schema, and read-only annotations, the description is nearly complete. It doesn't say what the output schema contains, but the output schema exists so it needn't. It also doesn't state how to release/use the prepared message, which is a modest gap given the tool's name 'prepare_arcade_session'.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds the key semantic constraint: the message is for 'one thirty-day, game-only session' and is 'owner-readable', which clarifies what the tokenId and owner are used for. This is a meaningful addition above schema descriptions.

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

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

The description uses a specific verb ('Builds'), a precise resource ('the exact owner-readable message for one thirty-day, game-only session'), and explicitly distinguishes itself from opening/signing operations. Among 45+ sibling tools, the phrase 'game-only session' and 'neither signs nor opens' make it clear what this prepare_* tool does and what it does not do.

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 names the sibling family (prepare_* tools) implicitly by position and clarifies this one is for a session. It states the tool is for building a message, not for signing or opening, which signals when to use it versus verify/sign/execute tools. However, it does not explicitly name a specific alternative like 'activate_agent_entry' or 'play_arcade_move' nor state when the session message should be used afterwards.

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 and destructiveHint, and the description adds genuinely useful behavioral context: ACCEPT 'can lead to one credentialed claim' while other states 'record a decision without minting', plus an explicit no-sign/no-submit guarantee that reinforces the read-only safety profile. However, it doesn't elaborate on idempotency implications, return-value semantics, or the operational consequences of each decision beyond the single claim note, leaving material disclosure gaps.

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 3 sentences, 47 words, with each sentence earning its place: core function, state semantics, and safety boundary. It is front-loaded and zero-waste, though the word 'unsigned' in sentence one slightly overlaps conceptually with the 'never signs' guarantee in sentence three, a minor redundancy keeping it just under a perfect 5.

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

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

For a prepare-tool with 12 parameters, only 25% schema coverage, and no parameter-level documentation, the description could not possibly carry the full context load — and it doesn't. The state-machine summary and the no-side-effects note provide a serviceable mental model, and the output schema presumably covers returns, but critical invocation details (which hashes are conditional, what allocations mean, how deadline/nonce are derived, whether framework is fixed or free-form) are absent, making correct parameter population a guess on 9 of 12 params.

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

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

With schema description coverage at only 25%, the description carries a heavy compensation burden but provides almost none: only the three decision values map to the 'decision' param's enum, while cryptic parameters like 'framework' (maxLength 100), 'allocation' (two opaque enums), and the purpose of 'reasonHash' versus 'manifestHash' versus 'statementHash' are left entirely unexplained. The low-coverage rule applies squarely here — the description fails to fill the gap.

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

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

The description uses a specific verb ('Prepare'), a concrete resource ('unsigned v5 typed data' for a census receipt), and enumerates the three decision states, clearly distinguishing their outcomes. It stops short of a 5 because it never explicitly differentiates itself from the many other prepare_* siblings (prepare_agent_entry, prepare_arcade_session, etc.), leaving the agent to infer the difference from the census/decision domain rather than being told directly.

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 boundaries by explaining the three decision states and stating what the tool does NOT do ('never signs or submits the receipt'), which hints that a different tool handles those steps. However, there is no explicit when-to-use guidance, no named alternative, and no mention of when an agent should pick a different prepare_* tool, leaving usage routing to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds meaningful context beyond that: it 'never signs or publishes' and builds a 'short-lived' heartbeat, implying local computation with no side effects and a time-sensitive output. This valuable behavioral disclosure is consistent with the annotations, so 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 wasted words. The main action and key scope come first, and the critical exclusion ('never signs or publishes') is placed in the second sentence for emphasis. Efficient and well-organized.

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

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

For a two-parameter tool with rich annotations, a precondition, an explicit non-behavior, and an existing output schema, the description covers everything an agent needs to decide and call it correctly. It doesn't explain what the heartbeat will later be used for, but that is not required for invocation and is partly implied by 'EIP-191' and the presence-delegation 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 100%, so the schema already documents both parameters. The description adds no material detail beyond referring to 'agent address' and the 'NFH' concept, which slightly reinforces the agent parameter but doesn't go beyond what the schema fields already convey. 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 names a specific verb ('Builds'), a precise resource ('short-lived EIP-191 heartbeat'), and a clear scope ('for an agent address that already has an active owner-signed presence-only delegation'). It also distinguishes itself from publish/sign-style siblings by stating 'The tool never signs or publishes.' This is more than enough for an agent to tell it apart 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 gives an explicit precondition ('already has an active owner-signed presence-only delegation'), which clearly signals when this tool applies. It doesn't name alternative tools or state a when-not condition, but the inclusion of 'already has' implies the rule that this should not be used before a delegation exists, providing clear though implicit context.

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

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

With annotations already establishing readOnlyHint=true and destructiveHint=false, the description earns its keep by disclosing critical runtime behavior: it always returns a specific error code, produces zero transaction steps, and explains the root cause (the ABI fails to bind price, minimum proceeds, offer hash, or version). This gives an agent genuine insight beyond the safety annotations, though it stops short of describing conditions under which behavior might change.

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 front-loads the most important fact (a fail-closed refusal) before explaining the rationale. Every clause earns its place — the error code, the zero-step result, and the binding rationale. It remains slightly heavy on protocol jargon, but there is no wasted verbiage.

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 low complexity (3 flat scalars, no enums, extra props disabled) and the presence of both descriptive annotations and an output schema, the description is largely complete. The only gap is that the description presumes knowledge of what CONTRACT_PRICE_BINDING_REQUIRED means and under what (if any) circumstances a real transaction might be prepared instead.

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

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

The schema already documents all three parameters at 100% coverage, establishing the baseline of 3. The description adds marginal value by referencing the acceptOffer(tokenId,buyer) signature, which hints at how tokenId and buyer map to the underlying contract call, but it does not meaningfully enrich the schema's parameter semantics.

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

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

The description uses a specific verb ('Returns') with a concrete outcome ('a fail-closed CONTRACT_PRICE_BINDING_REQUIRED refusal and zero transaction steps') and names the exact resource/function involved ('the deployed acceptOffer(tokenId,buyer) ABI'). It clearly differentiates this tool from working acceptance paths like prepare_mainnet_accept_offer, though it does so behaviorally rather than by explicitly naming 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 usage context is implied rather than stated: since the tool always fails closed, an agent can infer that calling it is a safety dead-end rather than a path to a real transaction. However, no explicit when-to-use guidance or alternatives are named, and siblings like prepare_accept_offer or prepare_mainnet_accept_offer are neither mentioned nor contrasted.

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 set readOnlyHint=true, and the description reinforces this is a preparation step ('prepare the exact call') and adds context: 'at its exact price', 'on our own Sepolia marketplace contract', and 'Royalty is paid automatically at settlement'. No contradiction, and adds useful behavioral context beyond 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, no filler. The main purpose is front-loaded, and the royalty note is a relevant behavioral detail. Every word 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?

With an output schema present and annotations covering safety, the description covers the essential purpose, context (internal/Sepolia), and a key nuance (exact price, royalty). It doesn't mention prerequisites like existing listings, but that is likely inferable for an agent familiar with the domain. Complete enough for correct invocation.

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