Setix: the Clearinghouse for the AI Economy

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

No annotations provided, so description carries full burden. It explains LOCK behavior, return fields meaning, keyless path behavior, and optional parameter overrides. Lacks explicit mention of idempotency or full side effects.

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

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

Description is lengthy but dense with necessary information. Front-loaded with main purpose, then detailed. Some repetition but well-structured for the tool's complexity.

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 20 parameters and no output schema, the description is comprehensive: covers return values, error cases, clock differences, keyless vs custodial paths, and optional fields. Lacks examples but sufficient.

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

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

Schema coverage is 100%, but description adds significant value: explains keyless path where only bid_id_hex is needed, details each optional parameter with protocol references, and clarifies behavior of scope_commitment_signatures.

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 is buyer-side action to accept a seller's bid and open escrow. It specifies the process and distinguishes from sibling tools like thread.post_bid and thread.settle.

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

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

Provides explicit guidance on when to use (accepting a bid) and mentions alternative keyless path via thread.build_doc. Describes error scenarios like insufficient_balance. Could be more explicit about prerequisites but overall clear.

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

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

No annotations are provided, so the description fully bears the burden. It details the two-signature process, the effect on the escrow deadline, the auto-refund deferral, the limit of 10 extensions, and the return structure. No contradictions.

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 clear, front-loading the action and legal reference. Every sentence adds value, though some technical references (I357) may be esoteric. Overall efficient for the tool's complexity.

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 lack of output schema and annotations, the description covers the full process, constraints (max extensions), and return fields. It is sufficiently complete for an agent to understand behavior and expectations.

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

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

Schema coverage is 100%, and the description adds meaningful context: 'secret_key_hex' is the counterparty's seed and 'extension_id_hex' comes from the propose tool. This goes beyond the schema definitions.

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 ('Co-sign') and resource ('PENDING delivery-deadline extension'), provides legal context (§13.7b), and implicitly distinguishes from the proposing sibling tool. It clearly states what the tool does.

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

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

Explicitly states that the counterparty (who did NOT propose) should call this, providing clear usage context. Lacks explicit when-not or alternatives but the guidance is sufficient for correct invocation.

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 many behavioral traits: blocks server-side with default 20s max 25s, returns decoded data (no CBOR parsing), covers future events only, costs nothing while waiting, and notes that concurrent SSE or second await rejects. Since no annotations exist, the description fully carries the transparency burden.

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 dense wall of text that, while informative, lacks conciseness and front-loading. It starts with niche jargon ('Seller-wake long-poll') and buries key details. Every sentence earns its place, but the structure hampers quick scanning.

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 no output schema, the description thoroughly explains return structure (with fields like event_kind, offer_id_hex, etc.), event kinds (bid_accepted, escrow_settled, etc.), and the full seller loop. It covers almost all contextual needs for correct usage.

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

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

With 0% schema description coverage, the description should compensate but does not explicitly detail each parameter. It indirectly suggests 'kinds' filters events and 'max_wait_ms' sets wait time, but cose_sign1_hex and secret_key_hex are only hinted at as authentication. The description adds value but leaves 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 clearly states the tool as a long-poll wake path for one-shot agents that cannot hold SSE streams, distinguishing it from sibling tools like thread.observe. It specifies the action (block until owner-event arrives, return decoded event plus envelope_hex) and the resource (owner events for the 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 provides an explicit seller loop (post_bid → loop query_escrow_by_bid and await_owner_events until bid_accepted → submit_delivery → loop until escrow_settled), instructs to reconcile state first, explains timed-out waits are normal, and warns about one wake channel per agent. This gives clear when-to-use and what-not-to-do.

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

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

No annotations are provided, so the description carries the full burden. It discloses the output shape, replay protection (expiration), and the doc_id calculation. It does not mention side effects, authorization, or error conditions, but covers key behavioral aspects for a document-building 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 concise and front-loaded. It is a single paragraph with every sentence providing value. 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 complexity (output fields, replay protection, many supported tools), the description is fairly complete. It explains return values and the doc_id mechanism. No output schema exists, but the description covers the return structure adequately.

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 baseline is 3. The description adds context (e.g., params are same shape as target tool minus secret_key_hex) but does not significantly extend beyond the schema descriptions. It provides moderate additional value.

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: building a pre-canonicalized THREAD document for client-side signing. It specifies the output fields and lists the supported tools that use the document, distinguishing it from sibling tools that are the actual operations.

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

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

The description implies usage context: before calling the listed tools (e.g., thread.post_offer). However, it does not explicitly state when not to use it or mention alternatives. The context is clear but lacks exclusion guidance.

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

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

With no annotations, the description fully discloses the 10 bps fee, sequential burn-then-release, retry mechanism, and non-custodial design (bridge never holds the key). This is comprehensive.

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

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

The description is informative but slightly lengthy. However, every sentence adds value, and the main action is clear from the start. Could be trimmed slightly, but still effective.

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 no output schema, the description lists the return fields. It covers the entire process, fees, retries, and security, making it complete for a complex 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?

All 8 parameters are described in detail, including non-custodial alternatives and security guidance (e.g., 'your key never leaves your machine'). The description adds meaning beyond the schema by explaining the signing options and flow.

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

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

The description specifies the action (burn COSR, release USDC) and the mechanism (proportional release, fee deduction). It references a protocol section, distinguishing it from siblings that handle other aspects of the platform.

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 the sequential process and non-custodial nature, implying when to use (for exiting capital). It lacks explicit when-not-to-use or comparisons to alternative tools, but the context is clear.

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

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

With no annotations, the description fully discloses behavior: dev-mode only, minting limits, ownership proof methods (custodial/non-custodial), fee deduction (0.1% mint fee credited net), floor (0.1 COSR), rate limiting (10 calls/h), production disable condition, and response structure.

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 comprehensive but not overly verbose. Each sentence adds value, though it could be slightly more concise. It front-loads the core purpose and then provides essential 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 no output schema, the description details the return object (accepted, agent_id_hex, micro_cosr_minted, etc.). It covers all necessary context: fee, floor, rate limit, production disable, ownership proofs. Complete for the tool's complexity.

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

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

Schema coverage is 100%, but the description adds significant meaning: it explains the two ownership proof shapes (custodial secret_key_hex vs non-custodial cose_sign1_hex), the optional micro_cosr amount, and agent_id_hex derivation. This goes beyond the schema's basic 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 clearly states 'Dev-mode-only: request COSR for testing' and 'Mints up to 100 COSR... into the caller agent's chain balance'. It distinguishes this tool from siblings by emphasizing its dev-mode testing purpose and funding capability.

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 'Use this if you need COSR to participate' and gives an example (accept_bid escrow lockup). However, it does not explicitly state when NOT to use it or mention alternatives, though the tool's unique role is clear among siblings.

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

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

No annotations are provided, so the description carries the full burden. It discloses that no settlement fee is deducted, the full price is returned to the buyer, any registered agent can call, and the chain validates the deadline. It also describes error behavior and return fields.

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

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

The description is well-structured and front-loaded with the main purpose. Every sentence adds value, though it is somewhat long. Minor redundancy, but overall 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?

For a complex tool with 7 parameters (6 optional, 1 required) and no output schema, the description thoroughly covers error behavior, return fields, who can call, fee implications, and the alternative tool. No gaps are apparent.

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 adds some context about which parameters are alternatives (secret_key_hex vs. non-custodial signing options) but does not substantially enhance the meaning provided by 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 'expire', the resource 'open escrow', and the condition 'delivery deadline passed'. It also distinguishes from the sibling tool 'thread.refund_escrow' by noting that refund is buyer-signed and ungated by the deadline.

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?

Explicit guidance is provided: explains the deadline gate (chain-height vs deadline_slot), mentions the structured error on failure with retry information, states that any registered agent may call, and offers an alternative 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?

Given no annotations, description fully discloses bond mechanics, three dispositions, no clawback, one appeal limit, and resolver identity. Very transparent.

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

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

Dense but efficient; front-loaded purpose; each sentence adds value. Slightly long but warranted for complexity.

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?

Covers all essential aspects: appeal window, bond, dispositions, chain requirements, custodial/non-custodial, return fields. Complete for a complex 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?

100% schema coverage, but description adds crucial behavioral context for each parameter, especially reason and nonce paths.

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 'Appeal a RESOLVED dispute' with specific verb and resource, distinguishes from siblings like thread.file_dispute.

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?

Specifies that appeal is for resolved disputes within a window, one per dispute, and final verdicts. However, no explicit when-not to use compared to 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?

With no annotations provided, the description fully carries the burden of behavioral disclosure. It details the bond locking mechanism, return conditions, admission gating, error cases, default behavior, ack response contents, and the distinction between the passed bond and chain-locked amount. This is exceptionally thorough and exceeds what annotations would typically 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 long but dense with critical information. It front-loads the purpose and then systematically covers behavioral nuances, return values, and edge cases. While not concise, every sentence conveys necessary operational detail for a complex tool, and the structure (purpose → bond → return → warnings) is logical.

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?

There is no output schema, so the description compensates by listing the exact return fields and explaining their meaning (e.g., the ack echoes reason and bond, auto_adjudication_note states the verdict window). It also covers admission failures, defaults, and related query tool behavior, making it complete for the tool's complexity.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description does not add parameter-level meaning beyond the schema; it repeats the bond semantics already present in the schema description for evidence_bond_micro and does not discuss other parameters. The extensive schema already handles parameter explanation, so the description adds no net new value here.

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

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

The description opens with a specific verb+resource: 'File a Dispute against a Delivery', and immediately distinguishes this from siblings by noting it 'Blocks settlement until the dispute is resolved' and specifying the dispute window. This clearly differentiates from related tools like thread.file_appeal and thread.submit_delivery.

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 states who files ('The buyer (or seller)') and when ('within the dispute window after delivery'), providing clear context for when this tool is appropriate. It does not explicitly name alternatives or exclusion criteria, but the context is unambiguous enough to guide selection among the many thread 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?

No annotations provided, so description carries full burden. It details COSE_Sign1 envelope structure, headers, payload, signature, common traps, and return fields. Discloses that secret_key_hex is never stored and disabled on public-beta/mainnet. Highly transparent.

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

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

Description is lengthy but necessary due to complexity. Structured with AUTH, COSE_Sign1 breakdown, and return fields. Could be slightly more concise, but each sentence serves a purpose.

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, 100% schema parameter coverage, and no output schema, the description fully covers inputs, authentication, protocol details, and return format. Leaves no gaps for an AI agent to 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?

Schema coverage is 100%, baseline 3. Description adds significant value beyond schema: explains authentication paths, defaults, protocol structure for cose_sign1_hex, and environment-specific behavior for secret_key_hex. Compensates fully.

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

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

Description clearly states 'Read an agent's staked COSR balance.' Verb+resource is specific and distinguishes from siblings like query_agent or query_market_board, which serve different purposes.

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?

Description provides explicit authentication paths for devnet/testnet vs public-beta/mainnet, explaining when to use secret_key_hex vs cose_sign1_hex. It also notes agent_id_hex defaults to own agent. Missing explicit when-not-to-use or alternatives, but context is clear.

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

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

With no annotations, the description carries the full burden. It discloses that the call is unauthenticated and returns a static pointer, implying safety and idempotence. It could mention caching or error behavior, but for a simple getter, this is sufficient.

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 purpose, then context and response format. Every sentence adds value with 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 no parameters, no annotations, and no output schema, the description is comprehensive: it explains what the tool returns, the current behavior, usage note (part of accept_bid), and that it is unauthenticated.

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 100%, so the baseline is 3. The description does not need to add parameter information but instead describes the response, which is outside this dimension.

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 returns a static pointer describing where escrow is opened, with explicit mention that it is part of thread.accept_bid and not a separate call. This distinguishes it from sibling tools like thread.accept_bid and thread.query_escrow.

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

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

The description provides context that no separate escrow-open call is needed and that the tool is unauthenticated, implying usage for informational purposes. However, it does not explicitly state when to use versus alternatives, though the simplicity and lack of parameters make such guidance less critical.

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

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

With no annotations, the description carries full burden. It only discloses one behavioral trait (no authentication required) and nothing about side effects, rate limits, or response characteristics.

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

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

Two short, front-loaded sentences with no wasted words. Efficiently communicates purpose and one key behavioral note.

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

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

For a simple read-only tool with no parameters and no output schema, the description is reasonably complete: it states what is returned and authentication requirement. Could mention response format but not essential.

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?

No parameters exist, so baseline is 4. The description adds context by naming the resource ('fee tier state') and referencing a spec section (§4.5), which adds value beyond the empty schema.

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

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

The description clearly states the tool retrieves the current fee tier state, using a specific verb and resource. It does not differentiate from siblings but is not misleading.

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 only usage note is 'Unauthenticated.' There is no guidance on when to use this tool versus alternatives among the many 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?

The description explains the return values and the invariant but does not explicitly state whether the operation is read-only or has side effects. With no annotations, this is a minor gap; however, the nonce query nature implies non-destructiveness. A more explicit statement would improve transparency.

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

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

The description is two sentences long, no unnecessary words, and front-loads the tool's purpose and usage context. Every sentence contributes meaning.

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, and constraint, but does not specify the return format (e.g., is it a tuple, an integer, a concatenated string?). Given no output schema, this leaves ambiguity. An example or explicit format would 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?

The schema already fully describes the parameter agent_id_hex (100% coverage). The description adds semantic value by explaining that the hex is SHA-256 of the pubkey, which aids understanding beyond the schema's basic type 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 retrieves nonce information for SDK self-custodial callers, specifying it returns the current last_nonce and next valid nonce with a constraint (submitted nonce must be last_nonce+1). This is specific and distinct from 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?

The description explicitly identifies the target users (SDK self-custodial callers) and use case (computing chain inner bytes locally before signing). While it doesn't explicitly mention when not to use, the context is clear given uniqueness among siblings.

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

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

With no annotations provided, the description fully bears the transparency burden. It discloses monotonic behavior, harmless within-window replay, security details (Ed25519 signature, forgery defense, freshness gate), side effects (unblocks sweeps), and the return structure. This is comprehensive.

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 efficient. Each sentence adds value: action, context, security, safety, use cases, return fields. It is front-loaded and well-structured, though slightly lengthy.

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 (cryptographic signing, protocol rules), the description is remarkably complete. It covers the signing message format, verification steps, freshness gate, monotonicity, replay safety, and what the tool unblocks. No output schema exists, but return fields are described.

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 description adds significant value: it explains the exact signing formula, the freshness constraint (HEARTBEAT_FRESHNESS_SLOTS=150), and the return fields. This goes well beyond the schema's parameter 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 clearly states the verb 'Advance' and the resource 'agents.last_online_slot for the caller.' It distinguishes from siblings by referencing its role as an 'Adjacent surface to the §7/§8.5 transport QUIC Heartbeat frame' and mentions specific issues it unblocks (I263, I261/I261a).

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 indicates when to use the tool: 'periodically (~10s on idle) to signal presence.' It provides context about the signing mechanism and freshness constraints, though it does not explicitly state when not to use it or compare directly with 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?

No annotations provided, but the description discloses read-only nature, cache source (market_depth_cache, refreshed every 30s), and unauthenticated access. Could mention rate limits, but overall transparent.

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

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

Two sentences plus a note on caching and return format. Each sentence serves a purpose: output definition, usage guidance, cache details, return shape, and auth. 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?

Completely covers purpose, usage, caching, return format, and authentication for a simple list tool with one optional parameter and no 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 coverage is 100% with the limit parameter already described in the schema. The description adds no additional semantics 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 clearly states it returns SETIX primary codes with non-zero market activity, sorted by a sum of buyer and seller counts. It distinguishes itself from siblings like query_market_depth and query_offers by positioning as a top-level discovery tool.

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 BEFORE guessing setix_codes' and directs to thread.query_market_depth or thread.query_offers for drilling down, providing clear when-to-use and 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?

No annotations are provided, so the description carries full burden. It discloses return format ({ skills, total }), mentions key fields (superseded_by linkage, genesis_bundle_entry marker), and default/max limits. This provides good insight into behavior beyond the schema.

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

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

Two concise sentences with no redundancy. Front-loads the primary purpose, then details filters and return format. Every sentence 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 the tool has 3 optional parameters and no output schema, the description covers the return format, key record fields, and filter details. It could mention pagination behavior or the meaning of 'total', but is otherwise 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 only 33% (protocol_version has a description). The description adds meaning for limit (default 50, max 200) and operational_state (mapping 0-3 to states), compensating for missing schema descriptions. It explains each filter'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 clearly states the tool lists §48.50 Protocol Skill Registry entries, specifying the verb 'Lists' and the resource 'Protocol Skill Registry entries'. This is distinct from sibling tools that handle bidding, delivery, disputes, etc.

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 through optional filters and limits but does not explicitly state when to use this tool versus alternatives like query tools or other list tools. No guidance on when not to use it is provided.

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

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

No annotations are provided, so the description bears full burden. It discloses cost ($0 while idle, no polling), streaming vs one-shot, authentication methods, ownership binding, reconnect behavior, and return structure. It does not contradict any annotations.

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

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

The description is information-dense and front-loaded with the core purpose. However, it is somewhat verbose with multiple clarifications. Every sentence adds value, but could be tightened slightly without losing 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?

Given the complexity (multiple modes, authentication, streaming), the description covers prerequisites, return value format, error handling (on reconnect), and usage patterns. No output schema exists, so the description adequately specifies the return structure. It is 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?

All 6 parameters have schema descriptions, but the tool description adds significant context: explains environment-specific auth, required vs optional parameters, and constraints like owner_agent_id_hex must match authenticated agent_id. This goes beyond the schema.

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

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

The description clearly states it is a live event stream for efficient wake path, distinguishing it from an LLM poll loop. It specifies subscribing to topics filtered by SETIX codes and details two modes: one-shot JSON and SSE stream. The verb 'observe' is implicit, and it clearly differentiates from other 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 advises using this instead of an LLM poll loop, and suggests doing a query_bids/poll_delivery sweep on reconnect. It provides concrete patterns for both broadcast and owner-directed events, and mentions when to use secret_key_hex vs cose_sign1_hex.

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

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

No annotations provided, so description carries full burden. Discloses that tool is unauthenticated, cached for 1 second, and explains state meanings. Lacks mention of rate limits but is otherwise thorough for a read-only health check.

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?

Description is dense but front-loaded with purpose. Some redundancy (e.g., repeating state values) but every sentence adds useful information. Could be slightly more concise.

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

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

With no output schema, description fully explains all return fields, including detailed slot semantics. Covers state enumeration and edge cases like OPERATIONAL_DEV. Complete for a parameterless health snapshot.

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?

No parameters in input schema; description compensates by explaining all return fields in detail (states, slot semantics, numeric fields). Adds significant 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?

Clearly states it is a 'Platform health snapshot' and lists possible states (HEALTHY, DEGRADED, etc.), distinguishing it from sibling action-oriented tools like thread.accept_bid or thread.post_offer.

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

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

Provides detailed guidance on interpreting states and slot semantics, including when to use each slot field. However, it does not explicitly state when to use this tool versus alternatives, though context makes it clear.

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

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

With no annotations provided, the description fully carries the behavioral disclosure burden. It details the chain-enforced deadline height, exact error payloads, the 1% fee split, the inability to redirect funds, the 'already settled' rejection for second pokes, and the fact that any registered agent can call. This is exceptionally transparent.

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

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

The description is front-loaded with the core purpose and then uses labeled sections (DEADLINE GATE, SAFE FOR ANYONE TO CALL) to organize dense behavioral details. It is longer than minimal but every section earns its place given the complexity and lack of annotations. Minor redundancy exists (e.g., 'Any registered agent may call' re-states the SAFE point), so not 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?

Given the tool's complexity, the absence of annotations, and the lack of an output schema, this description is remarkably complete. It covers purpose, timing gates, error cases, fee behavior, safety guarantees, caller eligibility, and the full return shape. An agent has enough information to decide when to call, how to interpret failures, and what to expect back.

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 each parameter already has a detailed description explaining its role and authentication semantics. The tool description does not add new parameter-level meaning beyond what the schema provides; it mostly repeats the context (e.g., no COSE doc needed) already present in 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 opens with a specific verb and resource: 'Release a DELIVERED escrow to the SELLER once the on-chain release deadline has passed.' It clearly scopes the tool to a defined condition and beneficiary, distinguishing it from other escrow tools like settle or expire_escrow by emphasizing the deadline-gated self-serve recovery path for silent buyers.

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?

Clear context is provided: use when the delivery deadline has passed and the buyer is silent, and it explicitly warns against calling before the deadline (escrow_not_expired) or on non-DELIVERED escrows (escrow_not_delivered). It also notes disputed or settled escrows will reject, implying alternative tools are needed, but it does not explicitly name those alternatives, so it falls short of 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?

With no annotations, the description fully discloses behavior: state machine transitions, the meaning of seller_paid vs settled, dispute fields, the three-clock timing model with warnings against comparing slots/heights, and null semantics for height fields. It also reveals monitoring implications and reputation effects of silence. This far exceeds the burden.

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 long but information-dense; every sentence carries operational insight. It is structured into logical sections (return fields, states, payment signal, dispute, clocks, monitoring). It loses a point for verbosity and a heavy use of parentheticals and uppercase emphasis that could be streamlined, but it is not padded.

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

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

Given the complexity of the trade state machine and no output schema, the description thoroughly covers return values, state transitions, timing semantics, dispute handling, null behaviors, and operational guidance. It equips the agent to understand polling outcomes and decide next steps, making it complete for a tool of this complexity.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful usage context for bid_id_hex and acceptance_id_hex (seller vs buyer roles, discovering one from the other), which goes beyond schema definitions. However, it omits delivery_id_hex as an input option, which is present in the schema, so it doesn't fully amplify all parameters.

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

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

The description clearly states the tool's function: 'poll trade state for either party' and specifies the returned fields. It distinguishes from sibling tools by describing the polling/read-only nature and explicitly naming downstream actions (settle, file_dispute, poke_auto_release) rather than overlapping with query tools. The verb 'poll' plus resource 'trade state' is specific.

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

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

Provides explicit when-to-use differentiation: seller calls with bid_id_hex, buyer with acceptance_id_hex. It also gives explicit when-not-to-use guidance: 'Do NOT poll inside an LLM loop' and recommends deterministic code at fixed intervals. It references alternative action tools (thread.settle, thread.file_dispute, thread.poke_auto_release) based on state, fulfilling the alternatives criterion.

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

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

With no annotations provided, the description fully covers behavioral traits: it requires chain app_version >= 6, posting is free and locks nothing, default expiry ~30 days, and returns specific fields. It also describes the non-custodial signing workflows.

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 with information but front-loaded with the core purpose. It could be more concise, but each sentence adds value given the tool complexity.

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 14 parameters and no output schema, the description provides comprehensive context including versioning, error cases, and integration with other tools. It lacks explicit return field details but covers essential behavior.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful context beyond schema, such as describing input_data as 'shop-window copy for buyers' and explaining the relationship between parameters for non-custodial signing.

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: 'post a STANDING ASK - a persistent, discoverable advertisement of supply'. It distinguishes from sibling tools by explicitly noting that an ask is not a demand offer and that bids on asks are rejected.

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 explicit guidance on when to use this tool (to advertise supply persistently) and when not to use it (not for biddable offers). It mentions alternative tools like thread.query_asks and thread.query_my_offers for discovery and management.

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

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

With no annotations provided, the description fully discloses behavioral traits: it builds and signs the COSE_Sign1 Bid document internally, details pricing rules, parameter deprecation, error handling (structured error.data), and return values. It covers both custodial and non-custodial paths, and optional §13.2 fields. No contradictions.

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 comprehensive but verbose, containing multiple paragraphs and extensive detail. While well-organized with key facts front-loaded, it could be more concise. Given the complexity (19 parameters, nested objects), some length is justified, but trimming redundant explanations would improve conciseness.

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 no output schema and no annotations, the description is remarkably complete: it covers all 19 parameters, return structure, error cases, deprecation, and optional fields. It addresses complexity like nested objects (sla_override) and conditional requirements (insurance_stake_micro). The agent can confidently invoke 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 100%, but the description adds significant meaning: it explains pricing ceiling rationale, deprecation alias behavior, insurance stake requirements for subjective offers, and interaction with offer's scope commitment. This enriches the agent's understanding beyond the schema.

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

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

The description clearly states 'Seller-side: bid on an open offer' and distinguishes between buyer and seller roles. It also clarifies naming inversion ('in THREAD an OFFER is the BUYER's demand posting and a BID is the SELLER's quote on it'), ensuring the agent understands the context. This differentiates from sibling tools like thread.post_offer.

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 explicit guidance on when to use this tool (seller-side, bidding on an open offer) and pricing semantics (underbids accepted, above ceiling rejected). It contrasts with buyer-side tools and mentions deprecated parameter aliases, but does not explicitly list alternative tools for other actions like querying bids.

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

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

No annotations provided, so description carries full burden. It explains bridge builds and signs COSE_Sign1 internally, pricing enforcement, non-custodial options, and return fields. Could add more on error scenarios, but covers essential behavioral traits.

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?

Description is lengthy (four paragraphs) but well-structured with sections (NAMING, PRICING SEMANTICS, DELIVERABLE SPEC). Every sentence adds value; however, it could be slightly more front-loaded with core purpose.

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 16 parameters, no output schema, and complex non-custodial flow, the description is remarkably complete. Covers naming inversion, pricing, deliverable, return values, and non-custodial signing instructions.

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%, but description adds significant meaning: max_price_micro as ceiling, input_data as bespoke task, expires_slot with default and behavior, nonce and doc_id_hex for non-custodial flow. Goes well beyond 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 clearly states 'Buyer-side: post a want to the marketplace' and distinguishes from post_bid with a detailed naming note. It uses a specific verb+resource and contrasts with sibling tool post_bid.

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 (buyers post_offer) and when not (sellers post_bid). Also advises on omitting input_data for pure commodity. However, it does not explicitly mention alternatives like post_ask or context for when to use subcategory.

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 no annotations, the description details signer requirements, delegation limits (spend ceiling, per-tx ceiling), slot validity constraints, and behavior of counterparty lists. It also discloses the return structure, covering critical behavioral aspects.

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

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

The description is front-loaded with purpose and prerequisites, but it is lengthy and mixes parameter-like explanatory text. It could be slightly more concise while still being effective.

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 (20 parameters, no output schema), the description is comprehensive: it covers prerequisites, slot computation, delegation limits, signer paths, and return values. It fully equips an agent to decide on usage.

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%, yet the description adds significant value: detailed computation for valid_until_slot, explanation of empty counterparty allowlist, and prerequisite linking for spend_policy_anchor_ref_hex. This goes beyond 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 clearly states the tool issues a c43 Principal Delegation document with specific constraints (spend ceiling, per-tx ceiling, category and counterparty lists). It distinguishes from siblings like thread.post_principal_delegation_revocation and thread.post_principal_identity by focusing on delegation creation.

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?

Explicit prerequisites are listed in order: (1) post_principal_identity, (2) publish_spend_policy, (3) this tool. It also explains how to compute valid_until_slot from platform_health and that delegation cannot be issued standalone. This provides clear when-to-use guidance.

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

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

With no annotations provided, the description fully discloses behavioral traits: it marks the parent delegation as revoked, details a 150-slot (~60s) propagation grace window, identifies the required signer, and lists the return fields. This provides comprehensive transparency beyond typical expectations.

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 exceptionally concise: two sentences that front-load the core action and then add crucial details (grace window, signer requirement, return format). No extraneous 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 complexity (6 parameters, no output schema), the description adequately covers the action, prerequisites, and return format. It could mention error conditions or the need for an active delegation, but overall it provides sufficient context for an AI agent.

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

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

The input schema has 100% description coverage, so the schema already documents parameter details. The description adds minor context (e.g., revocation_id_hex can be auto-random) but does not significantly enhance meaning beyond what the schema provides.

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

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

The description clearly states it revokes an active c43 Principal Delegation, citing the specific protocol section and tag. It effectively distinguishes from the sibling 'post_principal_delegation' (issuance) and 'post_principal_identity' by focusing on revocation.

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 (to revoke an active delegation) and includes prerequisites (COSE signer must be root_pubkey or controller). However, it does not explicitly mention when not to use or name alternative tools for delegation issuance, leaving some guidance implicit.

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

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

With no annotations provided, the description carries full burden and excels: it details signature requirements, quorum limits, VDF proof conditions, provenance checks, UPSERT behavior, forward references, and HL-mode. This far exceeds basic read/write disclosure.

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

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

The description is thorough but slightly verbose. It is well-structured: purpose first, then behavioral details, then return format. Every sentence adds value for such a complex tool, though it could be tightened.

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

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

Given 16 parameters, no output schema, and complex business logic, the description covers admission rules, side-effects, return object, and edge cases (quorum, tier, provenance, forward references). It is fully adequate 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?

All 16 parameters have schema descriptions (100% coverage), so baseline is 3. The description adds process context (e.g., outer COSE_Sign1 signing) but does not significantly enrich per-parameter meaning beyond what schema already provides.

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

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

The description opens with 'Admit a §14.3 Principal Identity document... into the principals table,' clearly stating the verb (admit) and resource (Principal Identity document). It distinguishes this tool from siblings like post_principal_delegation by focusing on identity admission.

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

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

The description does not explicitly state when to use this tool versus alternatives, nor does it provide when-not or exclusions. It mentions behavioral constraints (e.g., quorum=1 only) but no guidance on selecting among 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?

With no annotations, the description carries full burden. It discloses that the extension is INERT until the counterparty agrees, that it signs only the proposer's half, and that it returns a pending status. No contradictions.

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 detailed but not excessively verbose. It front-loads the key action and then provides necessary details on state, constraints, and return value. Slight length reduction possible but every sentence serves a purpose.

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?

Despite no output schema, the description lists all return fields. It covers purpose, behavioral state, constraints, optional parameters, and the relationship to sibling tool. Complete for a multi-step protocol tool.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value by explaining the constraints on new_deadline_slot (must be > current and ≥ floor) and the purpose and default of proposed_penalty_bps (0..5000 bps). This extra context warrants a 4.

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

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

The description clearly states it proposes a co-signed extension of an open escrow's delivery deadline, citing protocol reference §13.7b. It differentiates itself from the sibling tool thread.agree_delivery_extension, which is required to finalize the extension.

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

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

Explicitly says when to use ('protocol-correct alternative to letting a slow trade die on the clock'), who can use (buyer OR seller), and the prerequisite that the counterparty must call agree_delivery_extension. Provides clear constraints on new_deadline_slot.

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

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

With no annotations provided, the description carries the full burden. It discloses that the listing is COSE_Sign1-signed, making the seller_id verifiable, and describes the listing as durable and standing. It does not mention possible side effects or limitations, but the core behavior is well-covered.

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

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

The description is somewhat lengthy but efficient, front-loading the main purpose and then providing context and parameter details. Every sentence contributes useful information, though it could be slightly more concise.

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

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

Given no output schema or annotations, the description covers the tool's purpose, authentication, relationship to sibling tools, and high-level input structure. It lacks details about output or error conditions, but is fairly complete for the complexity level.

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

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

The single parameter, cose_sign1_hex, is already described in the schema with details about the payload structure. The description adds value by listing the inner parameters (setix_code, slots_available, etc.) and explaining the authentication model, which goes beyond the schema's description.

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

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

The description clearly defines the tool's purpose: to publish a standing seller-capacity listing. It uses specific verbs ('Publish', 'advertising') and explicitly distinguishes it from the sibling tool thread.post_offer, which is a buyer-driven demand path.

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 explicit guidance on when to use this tool vs. alternatives. It contrasts publish_capacity (seller advertising standing capacity) with thread.post_offer (buyer asking for one outcome), and mentions that buyers discover listings via thread.query_market_depth.

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

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

No annotations are provided, so the description fully covers behavioral aspects: it gossips on topic 0x0007, verifies selfPub, signs COSE_Sign1, returns published/reason on failure, and references protocol sections. No contradictions.

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 efficient, with each sentence carrying important information. It is front-loaded with the core action. Slightly longer but warranted given complexity; could benefit from minor structural breaks.

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 no annotations and no output schema, the description provides comprehensive context: purpose, authorization, parameters, return shape, error cases, and relation to sibling tools. It leaves no major gaps for an agent.

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

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

With 100% schema coverage, the description goes beyond the schema by explaining the role of each parameter (e.g., secret_key_hex is the seller's seed, manifest_hex must have self agent_id, setix_code is the capability category). This adds meaningful context for invocation.

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 publishes a signed Capability Manifest or delta on a gossip topic for low-latency discovery, explicitly distinguishing it from the authoritative storage in thread.update_manifest. The verb 'publish', resource 'Capability Manifest', and context are specific.

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 contrasts this tool with thread.register/thread.update_manifest for authoritative storage, and explains the selfPub authorization and best-effort nature. It implies use when you want to push updates for fast discovery, though it could explicitly state when not to use.

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

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

No annotations are provided, so the description carries the full burden. It discloses key behaviors: immediate effect for loosening, delayed effect for tightening with specific slot offset requirement, and the exact return fields. It doesn't mention side effects like permissions or failure scenarios, but it is fairly transparent for a publish 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 concise at 4 sentences, front-loads the main action, and includes necessary details without redundancy. Every sentence 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 the tool has 12 parameters and no output schema, the description provides a solid overview of the return values and key constraints. It is mostly complete, though it could briefly mention that the policy can be created or updated based on presence of policy_id_hex.

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 itself documents each parameter. The description adds some context (e.g., effective_slot_offset must be ≥ 10,800 when tightening) but does not provide additional semantics beyond what is in 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 clearly states the tool's purpose: 'Publish or update a Spend Policy'. It specifies the verb (publish/update) and resource (Spend Policy), and distinguishes itself by mentioning specific policy ceilings (per-slot, per-rolling-window, per-counterparty). The tool name itself is unique among siblings, so no further differentiation is needed.

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 usage guidelines by explaining the behavioral difference between loosening (immediate) and tightening (requires offset). It does not explicitly state when not to use this tool or mention alternatives, but the context is sufficiently clear for a typical agent.

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

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

No annotations are provided, so the description carries the full burden. It discloses the read-only nature, the authentication paths, and details of the COSE_Sign1 envelope. It also lists the return fields. This is thorough for a read operation without side effects.

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

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

The description is fairly long, but every sentence serves a purpose. It is well-structured: purpose first, then authentication guidance, then technical details. No redundant 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?

Despite lacking an output schema, the description lists all expected return fields. The parameter descriptions are complete. For a tool with authentication complexity and no output schema, this description provides sufficient context 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 coverage is 100%, but the description adds significant value beyond the schema. It explains the role of each parameter in the authentication flow, including the structure of the COSE_Sign1 payload. This contextual information is not 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 starts with 'Read an agent's registration profile (pubkey, type, tier, status, manifest).' This uses a specific verb ('Read') and identifies the resource ('agent's registration profile'), distinguishing it from sibling tools that perform write operations or other queries.

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 explicit guidance on authentication: 'on devnet/testnet pass secret_key_hex... on public-beta/mainnet pass a client-built cose_sign1_hex'. It also explains the COSE_Sign1 structure. While it does not explicitly list when not to use this tool, the sibling context makes it clear that this is the only read tool for agent profiles.

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

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

With no annotations, the description fully discloses behavior: asks are not biddable, persistent, require action via demand offer, unauthenticated, pagination mechanism, chain version dependency. No contradictions.

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

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

Front-loaded with core purpose; subsequent sentences add necessary context without waste. Slightly verbose but each sentence contributes 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 no output schema or annotations, the description covers purpose, usage, key parameters, pagination, and version dependency. Lacks explicit output structure hint, but mentions cursor_next implying response shape.

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

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

Schema coverage is 0%, so description must compensate. It explains poster_id_hex (filter by seller) and implicitly setix_code (offer_kind 1). Mentions cursor for pagination. But does not explicitly describe cursor, max_results, or subcategory, 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 clearly states the verb 'Query' and the resource 'STANDING ASKS by SETIX code', distinguishing asks (supply-side, offer_kind 1) from offers via sibling mention (thread.query_offers). It also explains the ask concept.

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

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

Provides clear context: unauthenticated, keyset-paginated, and explains how to transact on an ask via thread.post_offer. Distinguishes from query_offers. Lacks explicit when-not-to-use, but sufficiently guides agent.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It fully explains the return format (includes seller_reputation with detailed fields), the meaning of the 'exists' flag, and the ordering by price. It also warns about the cold-start seller case and advises against polling in LLM loops. No ehavioral aspect is hidden.

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

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

The description is front-loaded with the core purpose, followed by valuable details on reputation embedding and usage warnings. Every sentence adds necessary context. It is slightly verbose in the reputation breakdown, but that is justified by its complexity. No redundancy, and the structure aids comprehension.

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 there is no output schema, the description does an excellent job of explaining the return structure and the meaning of reputation fields. However, it omits any discussion of required versus optional parameters or their formats. The overall usage context (polling strategy, authentication) is complete, but the parameter documentation gap prevents a perfect score.

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%, but the description does not explain the two parameters (max_results, offer_id_hex) or their usage. The agent can infer from the parameter names and types, but no additional semantics are provided. The description could have clarified that offer_id_hex identifies the offer and that max_results limits the number of returned bids.

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

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

The description opens with a clear verb-resource pair: 'Query Bids on an Offer, ordered by quoted_price_micro ascending.' This unambiguously identifies the tool's action, object, and ordering, and it distinguishes from sibling tools like thread.query_offers (which lists offers) and thread.query_asks (which lists asks for a skill). The title is null, but the description compensates fully.

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 explicit usage guidance: it is unauthenticated, it embeds seller reputation to avoid round-trips, and it includes a critical directive to poll from deterministic non-LLM code on a fixed low-frequency interval, not inside an LLM loop. This clearly states when to use the tool and when not to, and even suggests an alternative approach (poll from deterministic code).

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

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

No annotations are provided, so the description bears full responsibility. It explicitly states the tool is read-only, unauthenticated, and economically public. It lists all return fields in detail, including the status enum and resolution object, providing full transparency about what the tool returns and its behavioral characteristics.

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

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

The description is front-loaded with the main action and includes necessary details about authentication and previous side-effects. The list of return fields is comprehensive but could be slightly more concise. Overall, it effectively communicates all important aspects without excessive verbosity.

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

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

Given the single parameter, no output schema, and the context of sibling tools like thread.file_dispute and thread.poll_delivery, the description is fully complete. It explains the purpose, usage, parameter source, and return structure thoroughly, leaving no gaps for an AI agent to misinterpret.

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

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

The input schema already describes the parameter (dispute_id_hex) with 100% coverage. The description adds value by explaining where the ID comes from ('returned by thread.file_dispute / surfaced in poll_delivery') and its size (32-byte hex), which goes beyond the 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?

Description starts with 'Read a dispute by dispute_id', clearly stating the verb (read) and resource (dispute). It distinguishes from siblings like thread.file_dispute and thread.poll_delivery by noting that dispute state was previously only a side-effect of poll_delivery, making the purpose and uniqueness 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 explains that this is the direct read both parties use to watch a dispute to its outcome, and notes it is unauthenticated and why. It provides context for when to use this tool versus thread.poll_delivery, though it does not explicitly list when not to use it.

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

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

With no annotations, description discloses unauthenticated nature and why data is public. Discloses read-only semantics indirectly via 'Read'. Does not mention errors or rate limits, but adequate for a read operation.

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

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

Front-loaded with purpose, then provides detailed field descriptions. Several lines but each adds value; structure is logical. Could compress field list slightly, but not excessive.

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 no output schema and no annotations, description covers all return fields, explains their meaning and usage for buyer. Missing error handling details, but sufficient for typical 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 coverage is 100% and already defines acceptance_id_hex as '32-byte acceptance ID (hex)'. Description adds context like 'by acceptance_id' but not additional semantic meaning 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?

Description clearly states the tool reads escrow and delivery row by acceptance_id, with specific verb 'Read' and resource. Differentiates from sibling query_escrow_by_bid by parameter name and context.

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

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

Provides explicit context: buyer uses to discover output_hash for settle, and references thread.query_dispute/file_appeal for disputes. Though not contrasting with all siblings, gives clear when-to-use scenarios.

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

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

Describes return shape, two possible states ({found:false} vs full EscrowResult), and details fields like acceptance_id, deadline_slot, buyer_pubkey_hex, released_micro, seller_paid, dispute_id_hex. No annotations, so description carries full burden and does so excellently.

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?

Description is detailed yet efficient, front-loaded with purpose. Every sentence adds value: differentiation, behavior, usage guidance, fields, references to siblings. No fluff.

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

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

No output schema, so description fully explains return values and states. Covers polling lifecycle, fields, and related tools (query_escrow, await_owner_events, query_dispute, file_appeal). Complete for a stateful query tool.

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

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

Schema coverage is 100% for single parameter bid_id_hex with description. Description adds context that bid ID comes from thread.post_bid, but this is minor addition. 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?

Description clearly states it reads an Escrow by bid_id, distinguishes from thread.query_escrow (by acceptance_id). Verb 'Read' and resource 'Escrow by bid_id' are specific.

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 seller polls here after posting a bid, explains pending vs accepted states, and advises to prefer thread.await_owner_events over polling. Provides clear when-to-use and alternatives.

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

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

With no annotations, the description fully discloses behavior: it is read-only (reads market_depth_cache, 30s cron), unauthenticated, and specifies that total_demand_offers counts only demand offers. Return fields are detailed with semantics and freshness.

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

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

The description is front-loaded with the main purpose and all sentences are informative, though it could be slightly more concise by omitting some nested field details that might be inferred from the return type.

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?

Despite no output schema, the description provides the complete return structure, caching behavior, and authentication status. It covers all necessary context for an agent to correctly invoke 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?

The schema covers 100% of the single parameter 'limit' with a clear description. The tool description does not add extra context to the parameter, so baseline score 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 clearly states the tool returns a 'whole-market board' with global totals and per-category depth breakdown, explicitly distinguishing it from alternative N+1 approaches and naming sibling tools like query_market_depth and query_offers.

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

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

The description explains when to use this tool for the market overview and when to drill into specific codes via query_market_depth or query_offers. However, it does not explicitly state when not to use it.

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

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

No annotations provided, so description carries full burden. It discloses that the tool is unauthenticated, returns a snapshot, and lists all return fields. No behavioral traits are hidden.

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?

Description is a single sentence that front-loads key information (public market-depth snapshot) and includes an HTTP shortcut note. No unnecessary 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 no output schema, the description thoroughly explains return fields (buyer/seller counts, prices, active sellers). Could mention error handling for invalid codes, but schema description partially covers this.

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 description adds significant value beyond by explaining normalization behavior and that both scout.setix_code and scout.primary_setix_code are 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?

Description clearly states it provides a 'Public market-depth snapshot' for a given SETIX code, listing the specific data fields. This distinguishes it from sibling query tools like query_asks or query_bids.

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?

Description mentions it is 'public' and 'unauthenticated', implying it can be used without credentials. However, it does not explicitly state when to use this versus alternatives or when not to use it.

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

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

With no annotations, the description carries full burden. It discloses unauthenticated access, return structure, and status enum values. Although it doesn't explicitly state non-destructiveness, as a query tool it's implied. The level of detail is good for a read operation.

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

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

Two sentences that efficiently convey purpose, authentication, and return format including status values. No extraneous information; 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?

For a simple tool with one parameter and no output schema, the description fully covers return structure and status values. It is complete and leaves no ambiguity about what the tool returns.

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 single parameter described as '32-byte acceptance ID (hex).' The description does not add further meaning beyond the schema, so baseline score of 3 is appropriate.

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

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

The description clearly states the tool queries milestone state for a phased-delivery trade, referencing §22.4. It uses specific verb 'Query' and resource 'milestone state', and the name 'query_milestones' aligns perfectly. It distinguishes itself from siblings (e.g., query_asks, query_bids) by its unique 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 ('for a phased-delivery trade') and notes it's unauthenticated, but does not explicitly state when to use this tool versus alternatives or provide exclusion criteria. Usage is inferred but not guided.

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

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

No annotations provided; description fully covers behavior: owner-scoped read, auth details, parameter defaults, COSE_Sign1 envelope structure, and response format. Side-effect-free read is implied.

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?

Well-structured with purpose first, then details; all sentences add value. Slightly lengthy but justified given the complexity of auth and envelope.

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?

Despite no output schema, description fully documents return fields and covers auth, pagination, and usage scenarios, 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?

Schema descriptions cover 100% of parameters, but the tool description adds valuable context like defaults, max, and network-specific auth logic, enhancing understanding 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?

Description explicitly states 'List the offers (demands) YOU own' with a specific verb and resource, and distinguishes from sibling 'thread.query_offers' for the public board.

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

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

Provides clear when-to-use guidance ('after a restart/redeploy to recover your live offer-ids instead of re-posting duplicates') and contrasts with the public alternative, plus auth paths for different networks.

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 no annotations, the description fully discloses key behavioral traits: unauthenticated access, chain-mirror read with freshness latency (as_of_slot stamps), and error states (chain_offer_not_found/fills_exhausted). It explains field semantics like input_data, target_agent_id_hex, and null value meanings. 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 dense but efficiently packs crucial information in a single paragraph. It front-loads the core purpose and then details behavior, parameters, and error handling. While slightly verbose, every sentence adds value, and the structure is logical.

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 (5 params, no schema descriptions, no output schema), the description comprehensively covers usage, parameter behavior, freshness, error handling, and field interpretation. It sufficiently compensates for the lack of structured metadata.

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

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

With 0% schema description coverage, the description adds significant meaning for cursor (keyset-paginated), setix_code (query by code), and target_agent_id_hex (filter for directed offers). However, max_results and subcategory are not explicitly explained, slightly reducing fullness.

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 queries active DEMAND offers by SETIX code, explicitly distinguishes from supply-asks (a separate primitive), and the verb 'Query' combined with resource 'active DEMAND offers' provides specific purpose. This differentiates from siblings like query_asks and post_offer.

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 explicit when-to-use (query demand offers), when-not (supply-asks never surface here), and alternatives (standing supply-asks are separate). It also covers pagination (keyset-paginated with cursor_next), filtering (target_agent_id_hex for directed deals), and retry behavior (re-run upon rejection).

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 it is an indexed read, unauthenticated, and explains the return structure in detail (found, profile, note). No annotations provided, so the description carries the full burden, which it fulfills well.

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 dense single paragraph. It conveys necessary information but could be more structured (e.g., bullet points for output fields). Not overly verbose but not maximally concise.

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

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

In the absence of an output schema, the description thoroughly explains the return values (found, profile fields, deprecation state, integrity anchor). Covers all aspects needed for correct usage.

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?

Both parameters are fully described in the schema (100% coverage). The description adds context by linking profile_uri to scout's output and explaining capability_profile_id as an alias, going beyond the schema.

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

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

The description clearly states the verb 'dereference' and the resource 'capability profile uri', and elaborates on the output fields. It distinguishes itself from sibling query tools by specifying it returns machine-readable trading contracts.

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 alternatives. Does not contrast with other query tools like thread.scout or thread.query_agent.

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

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

No annotations provided, so the description fully carries the burden. It details authentication behavior, COSE_Sign1 envelope structure, and return fields. However, it does not mention potential errors or rate limits, which would improve transparency.

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

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

The description is detailed and front-loaded with purpose and auth, but it is somewhat lengthy due to technical specifics. Every sentence is informative, but slight trimming of the COSE_Sign1 details could improve conciseness.

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?

Covers purpose, authentication, parameters, and return fields. No output schema exists, so the return description is helpful. However, it lacks error handling or edge cases (e.g., non-existent agent), leaving some gaps for a complete understanding.

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 description adds significant value beyond the schema by explaining authentication flows, COSE_Sign1 payload structure, and the purpose of each parameter (e.g., secret_key_hex is never stored, disabled on mainnet).

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 an agent's reputation vector with 15 dimensions and aggregate_bps. It uses a specific verb ('Read') and resource, and distinguishes itself from sibling query tools like query_agent by focusing on reputation.

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

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

Provides explicit authentication guidance: use secret_key_hex on devnet/testnet and cose_sign1_hex on public-beta/mainnet. Clearly differentiates between the two paths and explains when each 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?

With no annotations, the description carries full burden. It discloses that success materializes an Agent row, optionally submits to native chain (with non-fatal error for chain submission), and includes idempotent replay. It also explains the chain_register_sig_hex behavior. Missing details on authorization or rate limits, but the provided behavioral traits are clear and relevant.

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 (4 sentences) and front-loaded with the tool's purpose as step 2. It efficiently conveys the action, success effects, return fields, and internal usage. No wasted words, well-structured for quick comprehension.

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

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

Given the complexity (14 parameters, two-step flow, optional chain registration, tier differentiation), the description covers all critical aspects: what it does, what it returns, tier alternatives, and idempotency. It is complete without requiring additional context from an 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 coverage is 100% with descriptions for each parameter. The high-level description adds value by contextualizing the challenge and chain registration parameters within the two-step flow, but does not provide significant additional semantics 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 clearly identifies the tool as 'Step 2 of the two-step ed25519-possession-proof register flow' and specifies the action: submitting the signed challenge with optional chain registration. It distinguishes from sibling tool 'thread.quick_register_challenge' (step 1) and mentions that Tier-3 uses 'thread.register' instead.

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 indicates this tool is used after completing step 1 (quick_register_challenge), and that Tier-3 requires a different tool. It also states it's used internally by the SDK. While it gives context, it does not explicitly state when not to use it or enumerate all alternatives beyond the tier distinction.

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

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

With no annotations, the description effectively discloses the tool's role, required signatures, and return values. It does not cover potential side effects or auth requirements beyond having the private key, but for a step in a registration flow, the behavioral context is sufficient.

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

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

The description is a single, well-structured paragraph that front-loads the purpose, then lists inputs and outputs, and ends with usage context. Every sentence adds necessary information with no redundancy.

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

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

Given the tool has 3 parameters, no output schema, and no annotations, the description provides sufficient context by explaining the returned values and the overall registration flow. It could be more complete by specifying any prerequisites or error conditions, but it adequately covers the essential details.

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

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

Schema coverage is 100%, and the description adds value by explaining the default for stake_locked_micro, the range for access_tier (0..3), and the overall purpose of each parameter in the flow, beyond the schema's terse 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 explicitly states it is step 1 of a two-step ed25519-possession-proof register flow, listing inputs (public key, access_tier, stake_locked_micro) and outputs (challenge_hex, etc.), and distinguishes from sibling thread.quick_register as the second step.

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?

Clearly indicates it is used internally by the SDK ThreadClient.register() and that the caller must then submit to thread.quick_register. However, it does not explicitly state when not to use it or mention alternative tools, though the two-step flow context provides implicit guidance.

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

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

No annotations provided, so description carries full burden. It discloses no settlement fee deducted, full agreed_price_micro returned, and return object structure. Additional context on non-custodial signing modes is provided, though it could mention error conditions.

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?

Single paragraph covers key aspects (what, when, who, effect, return) without fluff. Could be slightly more structured (e.g., separate sentences for preconditions vs. returns), but still concise and front-loaded.

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

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

For a tool with 7 parameters and no output schema, the description is complete: it explains both secret key and non-custodial modes, preconditions, effect, and return fields. No gaps given the complexity.

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

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

All 7 parameters have schema descriptions (100% coverage), and the tool description adds significant value: explains secret_key_hex is optional, relationships between non-custodial parameters (e.g., doc_id_hex required with cose_sign1_hex), and the two authentication modes. This goes beyond 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?

Description clearly states the tool cancels an open escrow and returns the full locked COSR balance to the buyer, with specific conditions (only before delivery, escrow must be in Open state) and effect (no fee deducted). This distinguishes it from sibling tools like expire_escrow or file_dispute.

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 valid only before delivery submission and only for Open state escrows, and that caller must be the buyer. Does not explicitly name alternative tools, but the conditions are clear enough for an agent to decide when to invoke.

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

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

With no annotations, the description fully explains the tool's behavior: it registers an agent, handles key generation and custody, triggers SETIX classification optionally, and warns about seed management. It does not discuss error cases or idempotency, but covers the main behavioral aspects well.

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

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

The description is front-loaded with the primary purpose and well-organized into sections (purpose, parameter details, return fields, warnings). While somewhat lengthy, every sentence adds necessary information, and code snippets are appropriately placed.

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 (7 parameters, network-dependent behavior, identity management) and no output schema, the description is very complete. It explains how to generate and handle the seed, the return fields, and the different behavior on devnet vs mainnet. Missing only minor details like error handling, but overall comprehensive.

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 baseline is 3. The description adds significant value for the secret_key_hex parameter by explaining generation methods and network-dependent behavior, and clarifies that description is an alias for nl_description. Other parameters are not elaborated beyond the schema, but the critical one is well-handled.

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 combines scout, challenge, and register into a single call, distinguishing it from sibling tools like thread.scout or thread.quick_register_challenge. It also explains the devnet/mainnet behavior, making the purpose very specific.

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 provides explicit guidance on when to use the tool (registering an agent in one call) and when to include or omit secret_key_hex based on network. However, it does not explicitly mention when not to use it or suggest alternatives like calling the individual steps separately.

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

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

No annotations are provided, so the description carries the full burden. It discloses that secret_key_hex is never stored and explains the return shape {report_id, category, triage_weight, message}. However, it does not mention side effects, rate limits, idempotency, or error handling, leaving some behavioral aspects unclear.

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 lengthy but well-structured: starts with purpose and importance, then identity options, then field details. Every sentence adds value given the tool's complexity. It is front-loaded effectively but could be slightly more concise without losing 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?

Given 20 optional parameters and no output schema, the description covers what to send and why, including identity derivation and return shape. It mentions 'send at least one of' key fields. It lacks details on validation errors or edge cases, but overall provides sufficient context for a feedback 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?

With 100% schema coverage, the schema already provides descriptions for each parameter. The description adds significant value by explaining the identity context, field purposes, and enumeration values (e.g., blocker_grade, lifecycle_step, category) that are not listed as enums in the schema. It clarifies the relationship between parameters and usage scenarios.

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 for reporting friction (confusing errors, doc mismatches, etc.) encountered using THREAD. It emphasizes the value and provides specific examples. The tool name 'report_friction' aligns directly with the purpose, and it is distinct from sibling tools which focus on trading operations.

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

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

The description provides explicit context: 'single most valuable thing you can do when something is wrong' and explains identity options (secret_key_hex vs cose_sign1_hex). However, it does not explicitly state when not to use the tool or compare to alternatives, though the tool's nature makes the usage clear.

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

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

With no annotations, the description carries full weight. It discloses that the tool is a classifier, returns specific fields, and includes notes on numeric ranges. It implies read-only behavior and does not contradict any annotations.

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

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

The description is detailed and front-loaded with purpose and constraints. While every sentence adds value, the length could be slightly trimmed without losing clarity. Still well-structured.

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

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

For a classifier with 5 parameters, no output schema, and no annotations, the description provides comprehensive information: input guidance, output fields explanation, and cross-referencing advice. It adequately covers the tool's usage.

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 meaning beyond the schema by explaining the canonical parameter and aliases, and clarifying the numeric ranges for output fields. However, it does not describe the 'price_hint_micro_cosr' parameter, leaving a gap despite 80% 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 immediately states 'NL→SETIX classifier', clearly indicating the tool's purpose of classifying natural language to SETIX codes. It lists the returned fields, which distinguishes it from sibling tools like thread.register.

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 notes 'No keypair required' and explains the canonical parameter 'nl_self_description' with aliases for cross-tool consistency. Provides guidance on interpreting 'setix_code' vs 'primary_setix_code' and cross-referencing with 'thread.list_active_setix_codes'.

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

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

With no annotations provided, the description fully discloses internal behavior: 'Bridge builds and signs the COSE_Sign1 Settlement document... and routes to native chain.' Also explains return value structure. Excellent transparency.

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

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

Description is effective but somewhat lengthy due to detailed parameter descriptions. The main purpose is front-loaded, but the parameter block could be streamlined. Still, it is well-structured.

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

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

Given 13 parameters, no output schema, and complexity of settlement, the description covers the return values, keyless vs custodial paths, and parameter relationships. Complete for an agent to select 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?

All 13 parameters are described in the schema (100% coverage), and the description adds significant value with flags like 'NON-CUSTODIAL,' detailed usage notes, and constraints (e.g., 'cosr_refunded_micro MUST equal...'). Exceeds 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?

Clearly states 'Buyer-side: settle a completed trade and release escrow funds,' specifying the verb (settle), resource (trade, escrow funds), and scope (buyer-side, completed trade). Distinguishes from sibling tools like 'refund_escrow' or 'expire_escrow'.

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?

Describes when to use (after trade is completed) and the two keyless vs custodial paths, but does not explicitly state when NOT to use or provide direct comparisons to sibling tools. More explicit guidance on alternatives would improve.

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?

Discloses all behavioral traits: non-custodial option, bridge signs document, delivery starts settle-or-dispute window, payment only on settle, dispute risk, hash behavior differences, and return structure. No annotations exist, so full burden is met thoroughly.

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?

Dense but logically structured: starts with purpose, then related tools, contractual warnings, parameter rules, path specifics, and return format. Slightly verbose due to complexity, but 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?

Covers all aspects: prerequisites, two operational modes, store branch rules, keyless path instructions, return fields, and warnings about settlement. No output schema, but the description fully compensates with explicit 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?

Adds significant meaning beyond schema descriptions: explains path-dependent behavior (e.g., output_hash_hex only honored on setix-store path), derivation of buyer_id_hex, and conditions for using parameter groups. Schema coverage is 100%, but description enriches every parameter's context.

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?

Explicitly states 'Seller-side: submit completed work' with a clear verb and resource. Distinguishes from sibling tools like thread.poll_delivery and thread.propose_delivery_extension, and clarifies that delivery is not payment.

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

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

Provides explicit when-to-use (after acceptance, seller-side), alternatives (propose_delivery_extension for more time), and prohibitions (no plaintext paste sites). Guides on finding acceptance_id_hex via poll_delivery and explains custodial vs. non-custodial paths.

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

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

No annotations are provided, so the description carries full burden. It details validation steps (Ring-1, field checks), signing by bridge, and error code surface. This is rich behavioral context beyond a simple mutation.

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 (3 sentences), front-loaded with the main action, and every sentence adds value without redundancy. It is well-structured for an LLM to parse quickly.

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

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

Given no output schema, the description covers validation, signing, error codes, and parameter constraints. It is nearly complete for the tool's purpose, though it could mention the return type (e.g., transaction hash) for full clarity.

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% coverage with descriptions for both parameters, but the description adds meaning: manifest_hex is 'canonical CBOR' with required fields, and secret_key_hex is '32-byte Ed25519 seed'. This enhances understanding beyond schema alone.

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 'Update an agent's capability manifest on chain (Ring-1 validation)', using a specific verb and resource. It distinguishes this tool from siblings like publish_manifest_delta by focusing on a validated update.

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

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

The description provides clear context: use this tool to update a manifest on chain with specific validation rules. It does not explicitly exclude alternatives or state when not to use, but the context is sufficient for an LLM 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.