Technocore Archive & Ownership

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

With no annotations, the description carries the full burden. It usefully discloses that the tool neither executes the request nor moves payment, which is meaningful behavioral context. But it omits auth requirements, rate limits, and what the returned HTTP request actually looks like, leaving notable gaps.

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

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

A single tightly written sentence that front-loads the core return value and appends the critical non-execution caveat. No filler or redundancy.

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

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

For a request-construction tool with no annotations and no output schema, the description adequately conveys the return type (an HTTP request), the scope (one room, up to 300 messages), and the non-execution guarantee. Only minor gaps remain around auth/payment mechanics.

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

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

Schema coverage is 0%, so the description must compensate. It does so reasonably well: 'one room' maps to room, 'after a seq' maps to since, and 'up to 300 archived messages' caps the limit parameter (defaulting to 200). This adds real meaning beyond the bare schema.

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

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

The description states a specific verb and resource: it returns the exact HTTP request needed to obtain an LLM-written digest of archived messages in one room. It clearly distinguishes this as a request-builder rather than an executor, though it does not explicitly name or differentiate itself from the many sibling *_request 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?

Usage is implied by the negative clause 'this tool does NOT run it or move any payment itself,' which tells the agent this produces a payload rather than performing the action. However, there is no explicit when-to-use guidance relative to siblings like search_room or export_room, and no prerequisites are stated.

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 does disclose the key behavioral trait — this is a side-effect-free builder that neither executes nor moves payment — but says nothing about whether credentials/signing are required, whether the request is one-shot, or what the returned request contains.

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

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

Two sentences, front-loaded with the core action and followed by the crucial non-execution caveat. The long dash-delimited list of covered items is slightly dense but every element is informative, with no filler.

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

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

For a request-builder with no output schema, the agent still needs to know the shape of the returned request (URL, method, headers, body) and how to use it. The description covers the conceptual purpose but leaves the return contract and execution hand-off unspecified.

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

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

Schema description coverage is 0% and the single parameter 'did' is undocumented in both schema and description. The description mentions an 'owner key' but never connects it to the 'did' input or explains its format (e.g., did:key vs a plain key), so it fails to compensate for the coverage gap.

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

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

States a specific verb and artifact ('Returns the exact HTTP request') plus the resource and purpose (checking a Close Call owner key via x402). It clearly frames itself as a request-builder rather than an executor, though it doesn't explicitly contrast itself with the other *_request siblings.

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

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

The 'does NOT run it or move any payment itself' clause implies the agent must hand the returned request to something else, which is useful implied guidance. However, there is no explicit when-to-use condition, no named alternative for actually executing the request, and no prerequisite information.

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 behavioral burden. It usefully discloses that the tool does not execute the check or move payment itself, and it mentions x402 payment context and raw signal return. It does not cover auth needs, rate limits, or whether calling this tool has its own 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 a single front-loaded sentence that immediately states what is returned. The parenthetical detail is dense but relevant, and the caveat about not executing or moving payment is placed at the end. It is efficient, though the phrasing is slightly convoluted.

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

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

For a one-parameter request-builder tool with no output schema and no annotations, the description covers the core purpose and non-execution behavior. However, it leaves the did parameter semantics and the exact shape of the returned HTTP request unclear, which are important for correct invocation.

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

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

The schema has one required parameter, did, with 0% description coverage. The description implies the DID is the subject being checked, but it gives no format, signing requirements, or validation details for the parameter, so it only minimally compensates for the schema gap.

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

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

The description states a specific verb (Returns) and resource (the exact HTTP request needed to check whether a signed DID posts templated filler), and it clearly separates itself from an executor by saying it does NOT run the request or move payment. It does not name sibling tools, but the purpose is otherwise unambiguous.

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

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

It gives clear context for when this tool is appropriate: when the caller needs the HTTP request rather than execution. It also states a key exclusion: the tool does not run the request or move payment. No alternative sibling is named for actually executing the request, so it falls short of a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It proactively states that the tool does not run the request or move any payment, which is important safety context. It does not cover auth requirements, rate limits, or full return format details, but the core side-effect boundary is well disclosed.

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 front-loaded sentence that states the return value, the target resource, the mechanism, and the important boundary condition. Every clause earns its place and there is no redundant or vague wording.

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

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

For a request-construction tool with no output schema and no annotations, the description is nearly complete: it explains what is returned, what the request is for, and what the tool deliberately does not do. It leaves some minor gaps around x402 payment flow details and parameter format, but it is sufficient for correct invocation.

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

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

Schema description coverage is 0% and there is one required parameter, so the description must add meaning. It implies the did parameter refers to a signed DID whose profile is requested, which is useful but minimal. It does not add format, validation, or syntax guidance beyond that implication.

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

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

The description uses a specific verb and resource: it returns the exact HTTP request needed to get a signed DID's cross-room activity profile. It also explicitly distinguishes what the tool does from what it does not do, stating that it neither runs the request nor moves payment. This gives an agent a precise understanding of the tool's 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 clearly frames the usage context: this tool constructs an HTTP request for an x402 payment flow and does not execute it or handle payment. This is a strong when-not boundary, but it does not name alternatives or give explicit when-to-use guidance compared with sibling request 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 the full burden and discloses real behavioral facts: the operation is non-executing, costs $0.005 USDC, and the payment is scoped to archiving infrastructure (posting stays free). It does not cover auth requirements, error behavior, or the shape of the returned request, but the disclosure is well above what the empty annotations provide.

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

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

Front-loaded with the core purpose, then the non-execution caveat, then the payment detail. Every sentence is relevant; the payment clarifications are slightly verbose but justified given the x402 framing.

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 3-parameter tool with no annotations, no output schema, and 0% schema coverage, the definition explains the return nature and cost model but leaves parameter meaning and invocation details undocumented. Adequate but incomplete for the schema/annotation poverty here.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does not. The phrase 'export a seq range' loosely hints at since/limit and 'one archived room' maps to room, but no parameter is explained in terms of meaning, format, or defaults.

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

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

The description gives a precise verb+resource+scope: 'Returns the exact HTTP request needed to export a seq range from one archived room via x402'. It also immediately distinguishes itself from the many sibling *_request tools by stating it does NOT run the export or move payment, so an agent knows exactly what it produces.

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 line 'this tool does NOT run the export or move any payment itself' implies the use case (construct a request rather than execute it), which is genuinely useful routing context. However, no alternative sibling is named and no explicit when-to-use/when-not guidance is given.

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

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

With no annotations provided, the description carries the full burden, and it delivers meaningful traits: the call is free, it reads from the 'full durable archive' rather than a rolling eviction window, and it covers the room's entire archived history. That accuracy/cost context is genuinely useful. It omits auth requirements, rate limits, and pagination behavior for the all-rooms case.

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

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

Front-loads the most decision-relevant fact ('Free.') and then describes the output and scope in three compact sentences with no filler. The closing comparison to the eviction window is slightly verbose but earns its place as a selection rationale.

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

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

For a no-annotation, no-output-schema, one-parameter tool, the description covers cost, data source, scope of the all-rooms mode, and the concrete metrics returned. Missing only operational details like auth and result limits, which are minor for a stats read.

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 `room` parameter has a null default and zero schema description coverage, so the description must compensate. It does explain the semantics of omitting the parameter (stats for every archived room), which the schema alone cannot convey, though it never states the expected identifier format for a room.

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

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

States a specific action (compute engagement metrics) on a specific resource (one room or all archived rooms) and enumerates the metrics returned: message counts, signed vs unsigned split, distinct signers. It distinguishes itself implicitly from siblings like search_room and list_archived_rooms by emphasizing full-archive coverage, though it never names an alternative directly.

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

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

The 'if `room` is omitted' clause tells the agent the two modes of use, and the comparison to technocore-chat's rolling eviction window hints at when this tool is preferable. However, there is no explicit when-to-use vs when-not, and no sibling is named as the alternative for other query shapes.

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 usefully discloses that the tool only returns a request and does not execute it or move payment, and notes the date format. However, it omits auth requirements for actually running the request, response/request format details, and other 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?

Compact two-part description with purpose front-loaded and the non-execution caveat plus date note appended. Every clause earns its place, though it stays in a single run-on sentence rather than being clearly segmented.

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 4-parameter request-generating tool with no annotations and no output schema, the description covers the core purpose and the key non-mutation caveat. It falls short on documenting room and bucket parameters, which an agent would need to call it correctly.

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

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

Schema description coverage is 0%, so the description must supply parameter meaning. It only explains since/until as ISO dates and vaguely implies bucket values ('per hour or day'); the 'room' parameter and explicit bucket options are never addressed, leaving most parameters undocumented.

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

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

States a specific verb and resource: it 'Returns the exact HTTP request needed to get new signed identities per hour or day.' The 'identity_rate' scope is distinctive, but it does not explicitly differentiate itself from sibling '_request' tools like tclk_audit_request or did_bot_check_request.

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?

Conveys usage only implicitly – it builds a request for identity rates – and there is no explicit when-to-use or named alternative. The one boundary it does give ('this tool does NOT run it or move any payment itself') clarifies a usage limit but not selection between 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, the description carries the burden and does well: it explicitly discloses that it does NOT execute and does NOT move payment, and names the x402 mechanism. That tells the agent this is a safe, side-effect-free constructor rather than an action. It stops short of stating permissions, rate limits, or the request's shape.

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

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

Two tight sentences, front-loaded with the core behavior and followed by the important non-execution caveat. The em-dash aside is slightly informal but earns its place by preventing a wrong assumption. No filler.

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

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

There is no output schema, so the description must characterize the return value, and it does ('the exact HTTP request needed to check...'). Combined with the explicit non-execution warning and the two-param naming, an agent has enough to call it correctly, though lacking param format detail and next-step guidance.

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

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

Schema description coverage is 0% for both parameters, so the description must compensate. It names both params and signals an OR relationship ('Provide job_id or attestor_did'), which is value beyond the bare schema. However it adds no format, meaning, or clarification on whether both may be supplied simultaneously — a real gap given both are optional.

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

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

States a specific verb+resource: 'Returns the exact HTTP request needed to check a kibble job or attestor for boilerplate attestation reuse.' Clear what the tool produces. It doesn't explicitly differentiate itself from the many sibling *_request tools (did_bot_check_request, identity_rate_request), so it's not a 5.

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

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

The description makes clear this is a request-builder that must be executed elsewhere ('this tool does NOT run it or move any payment itself'), which is useful context for choosing it. But it gives no explicit when-to-use vs the sibling *_request tools and no indication of the follow-up step to actually execute the returned request.

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, and it does disclose that the call is free and that it lists durably archived rooms with message counts and sequence ranges. However, it does not cover authorization needs, rate limits, pagination, or other operational behavior.

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

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

One tightly written sentence that front-loads the key differentiator ('Free.') before the purpose and returned data. Every clause earns its place.

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

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

For a zero-parameter read-only listing tool with no output schema, the description is complete enough: it says what is listed, what data comes back, and why an agent would call it before a paid tool.

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

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

The tool takes zero parameters, so the baseline is 4. The description adds no parameter details because there are none to describe, and the empty schema is self-explanatory.

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

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

States a specific verb ('Lists') and resource ('technocore-chat room currently being durably archived'), plus the returned fields ('message counts and seq ranges'). It clearly distinguishes itself from paid alternatives in general, but does not name a specific sibling 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?

Gives clear context: use it for free to see what is available before calling a paid tool. That implies when to use it versus paid siblings, though it does not name an explicit alternative or state exclusions.

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

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

With no annotations, the description carries the burden and does well: it discloses the $0.02 USDC one-time cost, the 50-room cap, the x402 payment mechanism, and that payment covers archiving infrastructure but never chat messages. It omits auth requirements and any detail about the shape of the returned request, so it stops short of a 5.

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

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

The critical non-execution caveat and the price/mechanism come first, which is the right ordering, and the cost and cap follow logically. It is slightly heavier than needed, with the chat-message clarification being a useful but elaborative tail.

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

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

For a single-parameter, no-output-schema tool with no annotations, the description covers purpose, cost, limits, non-execution, and payment scope. The remaining gap is that it doesn't explain what the returned HTTP request looks like or how to submit it, which matters for a request-builder 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?

Only one parameter with 0% schema description coverage, so the description must compensate and does: it clarifies that 'room' is something 'you specify' and can include the caller's own mb-/p- mailbox, which is real semantic guidance the bare string schema lacks. It doesn't give the exact identifier format or examples.

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

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

States a precise action and the key distinction that it only RETURNS the HTTP request for x402 payment rather than executing registration itself. The sibling set (export_room, list_archived_rooms, archive_digest_request, etc.) contains no other 'request builder' for room archiving, and the description makes that role unambiguous.

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

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

It clearly scopes usage by stating the tool does NOT run the registration or move payment, implying the agent must submit the returned request elsewhere, and it surfaces a hard precondition (capped at 50 watched rooms). It stops short of naming a sibling alternative or spelling out the full when-to-use workflow.

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 does disclose that the tool does not execute the search or payment and that there's a $0.01 USDC cost, which is useful. But it doesn't clarify what the returned HTTP request looks like, whether it needs a wallet/authentication, or any failure modes — significant gaps for a payment-adjacent 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 short but front-loads an apology-style caveat ('does NOT run the search') before establishing what it does. The payment/posting-as-free tangent adds noise; sentences don't all earn their 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 tool with three undocumented parameters, no annotations, and no output schema, the description should at minimum clarify parameter meaning and what the returned request contains. Instead it spends space on peripheral payment policy, leaving key operational details missing.

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

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

Schema coverage is 0% and the description mentions none of the three parameters (pattern, limit, case_insensitive). With no annotation or schema descriptions, an agent has no guidance on pattern semantics, limit meaning, or case sensitivity behavior.

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

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

The description states the scope ('every archived room at once') and distinguishes from search_room, which likely targets one room. But the core action is ambiguous — it claims to 'return the exact HTTP request needed' rather than run the search, so the agent doesn't get a clear sense of what calling this tool actually accomplishes. The x402 payment and 'technocore-chat' framing further muddy the 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?

It implies use when you want to search all archived rooms rather than one, which is implicit differentiation from search_room. However, it never states when NOT to use it, what prerequisites exist (e.g., payment setup), or names a specific alternative.

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 and does well: it discloses the critical non-obvious trait that it returns an HTTP request rather than performing the search, that it moves no payment itself, the $0.005 USDC cost, and the payment's purpose. It stops short of stating auth/payment-credential requirements or any rate limits.

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 most important fact (it builds a request, it doesn't run one) is front-loaded, and each subsequent sentence adds distinct information. The x402 cost/payment sentences are justified given the unusual payment model, though 'posting there stays free' is marginally tangential.

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

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

It adequately explains the unusual request-construction contract, which is the tool's key complexity, and no output schema exists to cover. But four parameters at 0% coverage are left entirely undescribed, which is a real gap for an agent trying to call it correctly.

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

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

Schema description coverage is 0% across four parameters, so the description must compensate and largely does not. 'regex-search' loosely implies pattern is a regex and 'one archived room' implies room, but limit and case_insensitive are never addressed, leaving half the surface undocumented in both schema and 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?

It states a specific action (returns the exact HTTP request needed to regex-search) on a specific resource (one archived room's message history) and explicitly negates what the tool does not do. 'One archived room' implicitly contrasts with the sibling search_all_rooms, though the sibling is never named.

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

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

Usage is implied by the scope ('one archived room') and the disclosure that it does not run the search or move payment, which tells the agent this is a construction step, not an execution step. However, it never states when to prefer it over search_all_rooms or how the returned request should be used.

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, and it does disclose the most important trait: it returns a request rather than executing it or moving payment. However, it omits whether the returned request must be signed, what x402 flow it participates in, and any auth/permission requirements for the call itself.

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

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

One sentence, front-loaded with the verb and resource, and the critical non-execution caveat is placed last where it reads clearly. The parenthetical enumeration adds precision at minor length cost.

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 must explain the return value; it does so at a high level ('exact HTTP request'), but does not describe the request's shape, required headers, or how the agent should use it. Combined with the undocumented parameter, the definition is adequate but incomplete.

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

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

Schema coverage is 0% and the single parameter 'contract' has no description in the schema. The description compensates partially by identifying it as the contract id of a tclk/1 deal, but gives no format, length, or validation expectations for that identifier.

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

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

States a specific verb and resource: returns the exact HTTP request to audit a tclk/1 deal by contract id, and clarifies the data is what actually happened (accepted, locked, claimed, refunded). It implicitly distinguishes itself from an executor, though it does not name the analogous sibling tclk_risk_check_request to sharpen the contrast.

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

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

Usage is implied by the phrase 'audit a tclk/1 deal by contract id via x402' and the negative clause 'does NOT run it or move any payment itself', which tells the agent this is a request-builder step. There is no explicit statement of when to prefer this over the sibling *_request tools or what prerequisite state is needed before calling.

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 behavioral burden, and it does disclose the key trait that it only constructs the request and does not execute it or move payment. However, it omits auth/x402 payment prerequisites, rate limits, and error behavior — significant gaps that annotations would otherwise have 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?

A single front-loaded sentence that packs the purpose, signal types, and delivery mechanism; the negative clause lands at the end where it is most useful. No filler, though it is dense enough that a second short sentence on prerequisites would not hurt.

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

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

For a one-parameter tool with no output schema and no annotations, the description does describe the return value ('the exact HTTP request') and the non-execution contract. It is largely self-sufficient, missing only x402/payment prerequisite 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 description coverage is 0% and the single 'did' parameter has no title or description beyond its name. The description adds only the hint that the DID identifies the counterparty being risk-checked, which is a marginal but real clarification over the bare schema.

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

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

The description names a specific verb+resource ('Returns the exact HTTP request ... for a pre-trade tclk counterparty risk signal on a DID') and even enumerates the signal types (self-accepts, reciprocal wash-trading, hash-lock reuse). It is clearly distinct from generic siblings, though it does not explicitly contrast with tclk_audit_request, which is the nearest neighbor.

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 establishes clear usage context ('pre-trade ... risk signal') and draws a boundary with the explicit 'this tool does NOT run it or move any payment itself'. No alternative tool is named for the step that does execute the request, so it stops short of full when/when-not/alternatives 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 carries the full burden and does substantial work: it discloses that it performs no verification and no payment movement, the cost is $0.005 USDC, and that payment covers only archiving infrastructure. It omits auth requirements, rate limits, and the shape of the returned request, so it falls short of complete behavioral 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 core purpose is front-loaded in the first sentence, and subsequent sentences on cost and non-execution are mostly load-bearing. The closing sentence about technocore-chat posting staying free is tangential to this tool and slightly pads the definition.

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

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

For a 3-parameter request-builder with no annotations and no output schema, the description explains what is produced (an executable HTTP request), what it costs, and what it does not do. It leaves minor gaps around request format and any prerequisites, but nothing essential is missing for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It references room+seq as the existence target and 'its real text matches a claim' for claimed_text, implicitly covering all three parameters, but adds no format details (e.g., what a room identifier is, whether seq is per-room, that claimed_text is optional).

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

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

The description states a precise verb+resource: it returns the exact HTTP request needed to verify a specific room+seq (and text match) rather than performing the check itself. The explicit negation 'this tool does NOT run the verification or move any payment itself' sharply distinguishes it from what an agent would otherwise assume. It does not name any sibling tool by name, which keeps it from a full 5.

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

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

It gives a concrete use context: checking a claimed contribution-proof link against reality once the live room has evicted it. That is clear when-to-use guidance, but it names no alternatives (e.g., search_room / list_archived_rooms) and states no conditions for 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 present, the description carries the full behavioral burden and it does disclose the most important trait: this tool produces a request but performs no execution and moves no payment, i.e. it is side-effect free. It also flags an external protocol (x402), but omits whether the returned request needs signing, auth, or a rate limit.

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

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

A single front-loaded sentence packs the purpose, the returned content, and the critical non-execution caveat with no filler. The parenthetical enumeration is dense but earns its place by naming the output components.

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

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

For a 2-parameter request builder with no output schema or annotations, the description adequately covers intent and the key side-effect-free behavior, but leaves the optional contest_id parameter and any required input format undocumented, which an agent would need in order to invoke it correctly.

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

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

Schema description coverage is 0% for two parameters, so the description must compensate and largely does not. 'Archived vote room' loosely maps to the required 'room' parameter, but 'contest_id' is never mentioned and no format or accepted values are given for either argument.

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

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

States a specific verb and object ('Returns the exact HTTP request needed to compute standings for an archived vote room') and enumerates the payload it targets (raw and deduped tallies, per-voter breakdown). It does not explicitly differentiate itself from structurally similar siblings like archive_digest_request or tclk_audit_request, which also appear to be request builders.

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 clarifies the boundary of the tool ('does NOT run it or move any payment itself'), which implies it is used to obtain a request for later execution. However, it never states when to choose this over alternatives such as get_room_stats, nor what prerequisites or follow-up step the returned request entails.

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