Enclave402

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

Beyond the annotations, it discloses the exact hash mechanism (keccak256 of utf8), the fact that raw state is never stored, the attestor key location, offline verification via ethers.verifyTypedData, and settlement of $0.040 USDC with no charge on failure. These are meaningful behavioral details.

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

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

The description is dense but well-organized: core mechanism first, then usage conditions, exclusions, and pricing. Every sentence contributes meaningful information with no repetition or fluff.

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

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

For a two-parameter, non-idempotent, paid attestation tool with an output schema, the description covers purpose, invocation conditions, exclusions, cost/failure behavior, verification method, and data handling. An agent has everything needed to decide and invoke correctly.

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

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

The schema already describes both parameters fully, so the baseline is 3. The description adds extra semantic value by explaining that state is hashed and never stored, and that agentId is a stable identifier or EVM address, which goes beyond raw 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 precisely defines the tool: an EIP-712 signed, timestamped attestation over an agent state digest, binding agentId, hashed state, and the paying wallet. It clearly differentiates from siblings by explicitly excluding hardware TEE, zk proofs, and on-chain EAS.

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 MUST-use condition: when an agent needs third-party, non-repudiable proof of state existence at a point in time, with concrete examples like audit trails, hand-offs, and escrow. It also gives explicit Do NOT use guidance for other proof mechanisms.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false; the description adds settlement details ($3.500 USDC, no charge on failure), offline verification, and the attestation/signature structure. This enriches the behavioral picture without contradicting the annotations.

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

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

The description is three focused sentences: payload contents, when to use it, and cost/failure behavior. It is efficient and front-loaded, though it slightly restates the title's 'full signed dump' concept.

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, annotations covering safety, and the description providing cost, failure semantics, routing/analytics use case, and the sibling lookup alternative, nothing an agent needs to select and invoke this 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?

Schema description coverage is 100% for the only parameter (includeStale), whose description already explains its meaning. The tool description does not repeat or augment parameter details, which is appropriate; the baseline of 3 applies.

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

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

The description names the exact deliverable ('Whole-Bazaar seller census in one payload'), enumerates the row fields and signature artifacts, and explicitly contrasts with a single-lookup endpoint. An agent can tell it apart from census_verdict without opening the schema.

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

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

It states the trigger condition ('MUST be invoked when an agent needs the complete trust map for routing or analytics') and the exclusion ('Do NOT use for a single lookup (see /api/census/verdict)'). This leaves no ambiguity about when this tool is the right choice.

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, and idempotentHint=true, and the description adds non-redundant behavioral context: periodic re-probing (liveness, 402-envelope compliance, declared output schema, latency, usage), offline EIP-712 verification, and the settlement cost of $0.002 USDC with no charge on failure. 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?

Three sentences with no filler. The core purpose ('Pre-spend check') is front-loaded, the mechanics are compactly stated, and every clause contributes either behavioral context, routing guidance, or cost/failure 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?

With an output schema present, the description does not need to explain return values. It covers what is checked, how results are signed and verified, when the tool must be invoked, the excluded on-demand use case, and the cost/failure behavior. Nothing an agent needs in order to select and call this 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?

Schema coverage is 100%, so each parameter is already described. The description adds value beyond the schema by explaining the query modes that tie parameters together: 'Query one resource, a payTo, or page the feed by verdict,' which clarifies how resource, payTo, verdict, limit, and offset combine. This is more than a baseline 3 but not a fully detailed combinatorial breakdown.

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 verb-and-resource operation: a pre-spend check that maps Bazaar-indexed x402 resources or payTos to signed pay/caution/avoid verdicts. Specific verbs like 're-probed', 'mapped', and 'query' plus the explicit single-resource vs. bulk-feed modes clearly distinguish it from siblings like vet_seller and census_export.

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 states when to use: 'MUST be invoked before dispatching to an unknown seller.' It also states when not to use: 'Do NOT use to probe on demand (see /api/seller/vet),' naming the alternative and the condition that selects it. This gives airtight routing guidance.

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

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

The description adds value beyond annotations by disclosing the settlement fee ($0.001 USDC), no charge on failure, and the JWT decode caveat (no verification). While annotations already indicate readOnly=false, these extra details provide practical context for an agent's decision-making. It does not contradict annotations and offers useful operational 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 three sentences total, each with a distinct purpose: listing operations, stating when to use, and stating cost/failure policy. It is tightly written with no filler, and the core purpose is front-loaded. Every sentence earns its place.

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

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

Given the presence of an output schema and the tool's compute nature, the description is complete. It covers allowed operations, exclusions, usage, cost, and failure behavior. An agent has all necessary information to invoke the tool correctly without missing critical context.

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

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

Schema description coverage is 100% but the operation parameter's schema description is merely 'Operation to perform,' which is unhelpful. The tool description compensates by listing every possible operation value, providing essential semantics for the operation parameter. It also clarifies the purpose of input as 'Data to encode/decode,' matching the schema description but reinforcing it.

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

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

The description clearly states the tool is an encoding/decoding utility and explicitly lists all supported operations (base64, hex, URL, JWT decode, JSON stringify/parse). It distinguishes from sibling compute tools by explicitly mentioning it is NOT for cryptographic operations and directing to compute/hash, so an agent can immediately identify when this tool applies.

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

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

Usage guidance is explicit: 'MUST be invoked when an agent needs format conversion' provides a clear trigger condition, and 'Do NOT use for cryptographic operations (use compute/hash)' gives an explicit exclusion with an alternative. This fully informs when to choose this tool over 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?

Beyond the annotations, the description adds important behavioral context: the operation is deterministic, returns a hex digest, and has a settlement cost with 'no charge on failure.' It does not mention authorization, rate limits, or side effects, but the annotations already indicate it is not read-only and not destructive.

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: algorithms are front-loaded, the output format is stated, usage guidance is explicit, and the cost model is included. Every sentence earns its place.

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

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

The description covers purpose, supported algorithms, output format, invocation guidance, and billing/failure behavior. Since an output schema exists, return-value details are not needed. The main gap is that encoding values and KDF-specific parameters (e.g., salt or iteration handling) are not clarified, though the schema covers the key requirement.

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%, but the algorithm parameter is only described as 'Hash algorithm,' which is unhelpful. The tool description compensates by explicitly listing the accepted algorithms (SHA-256, SHA-384, SHA-512, HMAC-SHA256, PBKDF2, scrypt) and the hex output format. It still leaves the meaning of the 'encoding' parameter vague.

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

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

The description names a specific verb and resource: 'Deterministic hashing of arbitrary input' and enumerates exactly which algorithms are supported. It also states the return format ('Returns hex digest'), which makes it easy to distinguish from compute_encode, compute_infer, and other sibling tools.

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

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

It gives explicit when-to-use guidance ('MUST be invoked when an agent needs a cryptographic hash or key derivation') and explicit when-not-to-use ('Do NOT use for encryption or signing'). However, it does not name alternative sibling tools that should be used for encryption or encoding.

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

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

The description discloses a cost side effect not present in annotations: 'Settles $0.003 USDC; no charge on failure.' It also adds hard constraints (Prompt <=8000 chars, maxTokens <=1024) beyond what annotations provide. Since readOnlyHint=false and idempotentHint=false, this cost disclosure adds meaningful behavioral context that annotations alone do not convey.

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

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

The description is four sentences but packs purpose, usage, constraints, exclusions, and cost into a compact block. Every sentence contributes new information, though the title partially duplicates the same framing, making the overall title somewhat 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?

For a tool with an output schema and fully documented parameters, the description covers the critical gaps: cost, when to use, what not to use, and token limits. An agent has enough context to decide whether and how to call the tool without opening the schema, and the output schema 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?

Schema coverage is 100%, so the baseline is 3. The description restates constraints already present in the schema (e.g., 'json:true forces a JSON object' mirrors the schema's 'Force a JSON object response'; token and char limits match schema boundaries). It does not add new parameter semantics beyond reconfirming behavior already documented structurally.

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: 'Cheap small-model text completion for agent sub-tasks: classify, extract, summarize, rewrite.' This clearly distinguishes it from siblings like compute_encode, compute_hash, or compute_search, which are not text-completion tools. The title reinforces the input/output contract ('prompt in, text or JSON object out').

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

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

The description explicitly says 'MUST be invoked when an agent needs a short LLM answer without paying flagship rates' and 'Do NOT use for long-form generation or tool calling.' This gives both when and when-not conditions, leaving no ambiguity about the tool's intended scope.

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 openWorldHint=true and destructiveHint=false, so the description doesn't need to restate those. It adds valuable behavioral context: returns up to 10 results, settles $0.005 USDC, and no charge on failure. This goes beyond the annotations by disclosing cost and failure 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?

Three sentences with zero waste. The core purpose is front-loaded, usage guidance follows, and cost/failure behavior is stated compactly. Every sentence earns its place.

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

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

The description covers purpose, usage boundaries, result count, and cost behavior. With an output schema present, return values don't need to be explained. Minor gap: doesn't mention pagination or how to handle ambiguous queries, but for a search tool with this schema and annotations, it's nearly complete.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (query and limit). The description adds the 'up to 10 results' constraint, which aligns with the limit maximum, but doesn't add much beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Web search'), a clear resource ('ranked results with title, URL, description, and source domain'), and explicitly frames it for agent consumption. It distinguishes itself from sibling tools like compute_infer or get_market_signal by focusing on current web information retrieval.

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 when to use it ('MUST be invoked when an agent needs current web information') and when not to use it ('Do NOT use for cached/static data lookups'). This gives clear routing guidance relative to 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 establish readOnly, idempotent, and non-destructive behavior. The description adds valuable context beyond those annotations: the tool is free/no-payment required, should be called before paid operations, and exposes readiness and public transparency URLs. This complements the annotation safety profile without contradicting it.

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

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

The description is compact but information-dense: it front-loads the free/no-payment nature, lists the exact facts returned, states the mandatory usage point, and gives an exclusion. Every phrase earns its place with no filler.

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

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

With no input parameters and no output schema, the description still enumerates the returned facts in enough detail to set expectations. It also covers the critical sequencing requirement and the tool's non-application to market data or attestation, making it effectively complete for this simple info tool.

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

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

The tool has zero parameters and schema coverage is complete, so no parameter documentation is needed. Baseline for zero parameters is 4, and the description adds enough surrounding context to make invocation straightforward.

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

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

The description clearly identifies the tool's resource as gateway facts and prices, enumerating specific contents (network, payee, attestor, prices, readiness, ledger, transparency URLs). It explicitly separates itself from market data and attestation, which distinguishes it from sibling tools like get_market_signal and attest_agent.

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

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

The description gives an explicit timing instruction: 'MUST be invoked before the first paid call from a new agent.' It also provides clear negative guidance: 'Do NOT use for market data or attestation,' which helps an agent choose 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 declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds valuable behavioral context beyond annotations by disclosing the settlement cost of $0.010 USDC on Base and that there is no charge on failure, which is critical for an agent deciding to invoke the tool.

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

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

The description is compact and well-structured: it front-loads the core value proposition, lists the differentiating fields, states usage criteria and exclusions, and ends with cost and failure behavior. Every sentence earns its place, and the use of a colon-delimited field list makes the dense information easy to scan.

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

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

Given the output schema and annotations, the description is nearly complete. It covers use cases, exclusions, cost, and key return fields. It does not mention rate limits or latency, but those are not essential for correct invocation, and the settlement/failure disclosure is a strong addition for practical decision-making.

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

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

The input schema has 100% description coverage for both parameters (slug and limit), so the schema already explains their meaning and constraints. The description does not add extra parameter-level context beyond what the schema provides, so a 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: 'get_market_signal' returns Polymarket signal data with derived fields such as probability deltas, realized volatility, and whale flow. It clearly distinguishes this tool from alternatives by emphasizing it answers where a market is MOVING, not just where it is, which separates it from the sibling get_market_verdict and other listing tools.

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

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

The description explicitly says 'MUST be invoked when an agent needs where a market is MOVING, not just where it is' and 'Do NOT use for spot prices or order execution.' This gives the agent clear selection criteria and exclusions, leaving no ambiguity about when to use this tool versus 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 mark this read-only, idempotent, and non-destructive, and the description adds substantial context beyond them: the result is rule-based rather than a forecast, the attestation proves what was read and when, and a successful call settles $0.020 USDC with no charge on failure. This is exactly the kind of practical behavior an agent needs to know. There is no contradiction with the readOnlyHint since the charge is a billing disclosure, not a mutation of market data.

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

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

The description is dense but every sentence earns its place: result contents, non-forecast clarification, explicit usage rule, negative routing to the sibling, and cost/failure behavior. It is front-loaded with the core output and then adds usage and cost constraints.

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

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

With a single input parameter, full schema coverage, and an output schema present, the description still provides the essential behavioral and output context: full output contents, when to use, when not to use, and cost. Nothing an agent needs to decide whether to call this tool is missing.

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

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

Schema coverage is 100% and there is only one parameter, slug, which the schema already describes as a Polymarket market slug obtainable from market/signal. The description reinforces that the tool works 'by slug' and routes users to the sibling for discovery, but it does not add meaningfully beyond the schema.

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

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

The description names a specific verb and resource: it returns a rule-based verdict on one Polymarket market by slug. It also enumerates the precise contents (lean, 0-100 confidence, reasons, days to resolution, attestation), and explicitly distinguishes itself from market discovery tools like market/signal by stating it is not a forecast model.

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 invocation condition: 'MUST be invoked when an agent needs a defensible, timestamped read of a market.' It also provides an exclusion and alternative: 'Do NOT use to discover markets (use market/signal).' The fee and failure behavior further clarify when calling it is appropriate.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false, so the write-but-non-destructive nature is implied. The description adds valuable behavioral context: the $0.008 USDC settlement on Base, the guarantee that failed pins are never charged, and the size/type restrictions. This exceeds what annotations provide.

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

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

The description is compact and front-loaded: first the operation and result, then the must-use context, then explicit exclusions, then cost details. Every sentence earns its place with no filler, creating a clear and scannable definition.

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 (not shown but declared), return format is handled. The description covers usage context, all constraints (type, size, cost, failure behavior), and output expectations (CID + gateway URL). Nothing an agent needs to invoke this 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?

Schema coverage is 100% with clear descriptions for both parameters (content and name). The description adds extra meaning beyond the schema: the 8 KB serialized size limit, the JSON-only restriction, and the prohibition on raw binary and existing CIDs for re-pinning. These are important semantic guards not fully captured in the schema.

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

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

The description clearly states the verb (store), the resource (JSON document on IPFS), and the outputs (CID and gateway URL). It explicitly distinguishes this from sibling tools (compute, get, vet, etc.) by being the only storage tool, and it specifies constraints (8 KB, JSON only) that make the 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?

Explicitly states when to use: 'MUST be invoked when an agent needs durable, content-addressed storage...' It also lists exclusions: 'Do NOT send raw binary, files over 8 KB, or an existing CID to re-pin.' While it doesn't name alternative tools, the exclusion of re-pinning and binary signals clear boundaries, and no sibling offers similar storage.

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 readOnly/idempotent/non-destructive hints, it discloses the live 402 probe, CDP Bazaar reads, change-tracking since the last check, and the $0.010 USDC settlement with no charge on failure. The fee is a critical side effect that would otherwise be invisible.

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: action, scope, scheduling rule, exclusion, and pricing all earn their place. The most important usage constraint is front-loaded.

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

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

For a paid, scheduled, stateful vetting tool, the description supplies the missing operational context: when to call, what it probes, what it returns, and what it costs. A rich output schema covers the return details, so nothing essential appears absent.

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 both parameters at 100% coverage, including the important distinction that `resource` is the paid route, not the seller homepage. The description adds no per-parameter detail beyond what the schema provides, so the baseline of 3 applies.

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

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

Names a specific verb ('vet'), target ('x402 seller'), and exact deliverable ('scored LIVE/STALE/UNLISTED/MISCONFIGURED/UNREACHABLE verdict signed by our attestor'). The probe/Bazaar/trust-surface details make it easy to tell apart from generic market or census 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?

Explicitly states when it is mandatory ('MUST be invoked before a first payment to an unknown resource, or on a schedule') and gives a hard negative ('Do NOT use to pay it'). This gives an agent a clear decision rule.

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