Kairos Signal — verifiable DePIN data API

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

No annotations are provided, so the description carries the behavioral burden. It implies a read-only operation by saying 'Check' but does not state whether the operation is side-effect-free, what it returns, or whether there are rate limits. For a simple balance check, this is acceptable but not fully 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 terse and front-loaded with the core action. The second sentence adds practical usage guidance but repeats 'remaining,' making it slightly redundant.

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

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

For a one-parameter tool with no output schema, the description provides a complete enough picture: what it checks, when to use it, and the required authentication context. Minor omissions are the exact return shape and a clearer read-only guarantee.

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 fully documents the single parameter (api_key with 'Your API key') at 100% coverage. The description adds no additional parameter detail, meeting the baseline of 3.

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

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

The description clearly identifies the verb ('Check') and the resource ('remaining credit balance'), making the tool's function unambiguous and distinct from sibling tools like topup_credits or purchase_data.

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

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

It gives explicit context for when to use the tool ('Use after purchases'), which helps route an agent correctly. It does not explicitly list when not to use it or alternatives, but the API list makes the distinction reasonably 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 carries the full burden, and it does a solid job: it discloses the free-tier record cap, retention of rejected rows for depin_onchain, the limited validity of observation_quality, the meaning of not_checked, and the proof-hash coverage limitation. These are meaningful behavioral traits 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?

The first sentence immediately states the action and parameters, followed by terse, relevant caveats. The domain-specific details about depin_onchain and observation_quality are dense but necessary behavioral context, and no sentence is wasted.

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

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

Given that there is no output schema and no annotations, the description provides the critical context an agent needs: pagination parameters, free-tier limits, and important data-quality caveats. It does not cover ordering or error behavior, but for a read-only query tool the provided context is strong.

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

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

The schema already describes all three parameters, including the free-tier max of 10 for limit. The description adds no new parameter-specific meaning beyond restating limit/offset behavior, so it stays at the baseline for high schema coverage.

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

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

The description begins with a specific verb and resource: 'Query records from a dataset with limit/offset.' This clearly states the operation and distinguishes it from siblings like list_datasets, which are about enumerating available datasets rather than retrieving records.

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

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

The description makes the core use case clear by stating it queries records from a dataset, but it does not explicitly say when to avoid this tool or point to an alternative such as list_datasets. The usage is implied rather than directly compared against 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 communicates that this is an informational, machine-legible resource, that it is free and requires no key, and that it answers specific metadata questions. For a zero-parameter read-only tool this is solid behavioral disclosure, though it doesn't explicitly state 'no side effects' or describe the return format.

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

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

Three short sentences, front-loaded with the 'ONBOARDING SPEC' label, then the content scope, then the access constraint. Every sentence earns its place; there is no filler or redundancy.

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

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

For a no-parameter informational tool, the description is nearly complete: it names all covered feeds, the dimensions of metadata, the access requirement, and the machine-legible nature. It could be slightly richer by specifying the output format, but it provides enough for an agent to invoke and interpret the tool successfully.

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

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

The tool has zero parameters, so the schema carries no burden and the baseline is 4. The description still adds meaning by specifying what the dictionary contains (freshness, history depth, coverage, endpoints, feed names), which helps an agent understand the returned content even without an output 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 very specific purpose: it is an onboarding spec exposing freshness, history depth, coverage, and endpoints per named feed. It lists the exact data feeds covered and explicitly answers the 'how stale / how far back' questions, making it clearly distinct from sibling tools like fetch_dataset or list_datasets.

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

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

The phrase 'ONBOARDING SPEC' and the question 'how stale is this and how far back does it go' give strong contextual guidance for when to call it. It does not explicitly name alternatives or state when not to use it, but the intended use case is clear enough.

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

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

With no annotations, the description carries full behavioral disclosure. It mentions that values are 'free' and that the tool enables replay verification via provide verify_url and code hash, and states that divergence is mechanically detectable. However, it does not clarify the output format, whether any mutation is involved, or potential limitations. The cryptic language obscures operational behavior.

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

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

The description is a single unbroken sentence-like block that leads with a slogan and then meanders through verification concepts. It is neither concise nor front-loaded with the core action. The phrase 'DERIVATION TRUTH' is attention-grabbing but not informative, and the overall structure wastes space on rhetorical framing rather than clear functional statements.

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 must define what the tool returns, but it never explains the ledger's structure—whether it is a list of records with fields like payload, SHA, code hash, verify_url, etc. It mentions 'coverage list' but does not define it. For an agent to know what to expect from a call, this is incomplete.

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

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

The schema provides complete coverage for the single 'symbol' parameter, describing it as an optional filter and referencing the coverage list. The description adds no extra parameter context. Since schema coverage is 100%, the baseline of 3 applies; the description does not enhance or detract from parameter understanding.

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

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

The description never explicitly states that the tool returns the derivation ledger. It opens with the slogan 'DERIVATION TRUTH' and discusses SHA-256 pinning and replay verification, but the direct action ('get the ledger') is only implied by the tool name. It does add meaning (raw upstream payloads, hashes, code hashes) so it's not a tautology, but an agent must infer the primary function from 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?

No guidance is given on when to use this tool versus siblings like verify_footprint or get_zk_provenance. The description does not mention alternatives or exclusions. The only practical note is 'Free', which addresses cost, not usage context or prerequisites.

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 present, so the description must disclose behavioral expectations itself. The verb 'Get' implies read-only intent, but the description does not mention whether the operation is safe, cached, expensive, authenticated, or if it returns a single summary or a structured object.

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

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

The description is short and front-loaded, which is good for a trivial tool. However, it is under-specified rather than truly informative, so it is concise only in the sense of being short.

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?

Even though the tool has no parameters, it has no output schema and no annotations, and the description does not clarify what the output looks like, what 'databases' means, or when this tool should be preferred over sibling tools. An agent is left guessing.

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

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

The tool has zero parameters, so the input schema already fully describes the invocation contract. There is no meaningful parameter detail for the description to add.

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

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

The description identifies an operation ('get aggregate statistics') and a target ('databases'), but it is vague about what statistics are returned, from which databases, and in what scope. It does not distinguish the tool from siblings such as fetch_dataset or list_datasets.

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

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

There is no guidance on when to use this tool vs. the sibling tools, no exclusions, and no workflow context. An agent cannot tell whether this is the right tool for a user asking for a specific statistic or an overall dashboard summary.

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 has the full burden of disclosing behavioral traits. It states an expected return value but does not explain what 'cryptographic provenance proof' contains, whether retrieval has side effects, whether credentials are needed, or how it behaves when the record exists in multiple datasets.

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 names the action, the resource, and the scope with no filler words. 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 single-parameter tool, the description is minimally adequate, but it is not complete. There is no output schema and no explanation of the proof structure, potential errors, dataset selection semantics, or how this relates to sibling tools. The absence of annotations also leaves important safety and side-effect context uncovered.

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 fully documents record_id with a description, so schema description coverage is 100%. The description adds only a small contextual detail—'from current datasets'—which scopes the parameter but imposes no new format, constraints, or syntax beyond what the schema already provides.

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

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

The description states a specific verb ('Return') and resource ('cryptographic provenance proof for a record ID'), and scopes it to 'current datasets.' It is clear enough to convey the key operation, though it does not explicitly contrast with sibling tools like verify_footprint, whose purpose could overlap conceptually.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The phrase 'current datasets' hints at a scope limitation, but the description never mentions verify_footprint, dataset-specific conditions, or any exclusion criteria, leaving usage decisions to inference.

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

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

No annotations are provided, so the description carries the transparency burden. It clearly conveys a read-only, non-destructive operation through 'List' and 'Free to browse.' It does not discuss rate limits or authentication, but for a zero-parameter catalog listing, it adequately signals the behavioral outcome.

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 action and output ('List all available datasets with record counts'), then adds a concise, useful list of dataset categories. Every clause earns its place—there is no filler or repetition of the tool name.

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

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

For a zero-parameter, read-only discovery tool with no output schema, the description covers the essential contract: list datasets, show record counts, and browse for free. It doesn't specify output formatting or explicitly route to siblings, but this is complete enough for a simple catalog listing tool.

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

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

The tool has 0 parameters, so the description has no parameter details to add. The baseline for 0-param tools is 4. The phrase 'List all available datasets' confirms there are no filters or inputs needed, which aligns with the empty input schema.

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

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

The description states a specific verb and resource: 'List all available datasets with record counts.' This clearly distinguishes it from siblings like list_products (different resource), fetch_dataset (fetches a single dataset), and purchase_data (transactional). The added dataset-category examples reinforce the scope of the resource.

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

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

There is no explicit statement of when to use this tool versus alternatives. 'Free to browse' hints that this is a discovery/browsing endpoint before purchasing, but it does not say 'use fetch_dataset to get actual data' or 'use purchase_data to buy access.' Usage guidance is implied but not explicit.

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

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

With no annotations provided, the description carries the disclosure burden. It tells the agent this is a browsing/read operation, indicates the prerequisite of registration, and clarifies pricing units. It does not mention return shape or pagination, but those are less critical for a simple zero-parameter catalog listing.

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

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

The description is compact and front-loaded: the core action and pricing context are in the first sentence, while product categories and usage hint follow naturally. Every sentence contributes practical information without redundancy.

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

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

For a simple, parameter-free list tool, the description adequately conveys scope, pricing, included product families, and when it should be called. It could be slightly more explicit about returning product IDs for purchase_data, but the overall usage context is sufficient.

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

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

The tool has zero parameters, so the schema fully covers all inputs by construction. The description adds no parameter-specific detail because none is needed; per the 0-parameter baseline this 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 specifies the verb 'Browse' and the resource 'all purchasable products with prices in credits', making it easy to distinguish from dataset-listing siblings. It also adds concrete catalog categories, giving the agent a practical picture of what the tool returns.

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

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

The description gives clear operational context: call after register_agent to see what to buy. It does not explicitly name alternatives or exclusions, but for a top-level listing tool the intended position in the workflow 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?

The description discloses the key behavior—credits are spent and an api_key is required—so the agent knows this is a purchase/billing action. However, with no annotations provided, it does not disclose failure modes, irreversibility, or what happens after a successful purchase beyond the immediate action.

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

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

The description is only two sentences long, starts with the core action, and packs product context and api_key guidance without filler. It is easy to scan and no sentence is redundant with the schema.

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

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

For a two-parameter tool with 100% schema coverage and no output schema, the description is largely sufficient: it names the products, indicates the purchase action, and points the agent to the proper api_key source. A small gap is that it does not explicitly direct the agent to list_products for a definitive product catalog, but the sibling context makes this recoverable.

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 both parameters and gives example values. The description adds useful semantic context beyond the schema by listing the categories of purchasable products (for example GPU compute, MCP unlimited, and DAG manifold tiers), which helps the agent reason about valid product_key values.

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

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

The description states a clear user action ('Buy a product with your credits') and specifies the resource type, then enumerates supporting product categories keyed to product_key values. This clearly distinguishes the tool from siblings like register_agent, list_products, and topup_credits.

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

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

The context is implied rather than explicit: you purchase a product using credits, and you need an api_key from register_agent. There is no explicit instruction about when not to use it, such as pointing to list_products for browsing products or topup_credits for adding credits.

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 of behavioral disclosure. It discloses speed (~5 seconds), lack of payment/card/human involvement, and that credits persist. However, it does not describe side effects such as creating a persistent agent identity, potential uniqueness requirements on agent_name, or any account-related implications. It adds some useful context but omits important registration behavior.

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

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

The description is overly promotional and includes irrelevant platform features (DePIN telemetry, GPU inference, DAG manifold) that do not help an agent call register_agent. It also mentions an external URL as an alternative onboarding path. The core instruction is padded with marketing, making it less concise than it should be.

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 exists, so the description should state what the call returns; it does mention API key and $5 credits. It also gives a next step (list_products). However, it does not explain error conditions, whether agent_name must be unique, or how the returned API key should be used in subsequent calls. It is adequate but not complete for a registration 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%, with brief descriptions for email and agent_name. The tool description does not add any meaning beyond the schema; it does not mention how agent_name is used or what happens if email is omitted. With full schema coverage, baseline 3 is appropriate.

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

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

The description conveys that calling this tool is the entry point to get an API key and $5 free credits, which implies agent registration. It is clear about the outcome but never explicitly says 'registers a new agent'; the verb 'get' is used instead of 'register'. It differentiates as the 'START HERE' step among siblings, though it does not precisely name the action.

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 says to start here and suggests using list_products afterwards, giving a usage sequence. It also mentions that get_data_dictionary can be tried first if the coverage spec is wanted, offering an alternative. However, it does not explicitly state when not to use this tool or provide 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 provided, the description carries the full behavioral disclosure burden. It usefully discloses that the tool only creates an intent and returns transfer instructions rather than executing the transfer, and that the Stripe path requires a human operator. However, it does not mention side effects such as whether the intent expires, whether repeated calls create multiple intents, 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 description is two sentences with the main USDC flow front-loaded and the Stripe alternative concisely appended. Every sentence earns its place and there is 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, but the description covers the return concepts for both branches: transfer instructions and a Stripe checkout link. Given the fully documented parameters and simple branching logic, this is adequate, though the lifecycle of the top-up intent could be slightly clearer.

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

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

Input schema coverage is 100%, so the baseline is 3. The description reinforces that from_address is needed for USDC and that there are two methods, but it adds no parameter-level detail beyond what the schema already states.

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 creating a USDC top-up intent or a Stripe checkout link, with specific actions and resources. It is distinct from siblings like check_balance and purchase_data, though it does not explicitly contrast itself with them.

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

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

The description gives clear context: use the USDC path before transferring funds, and use Stripe when a human operator should complete checkout. It does not discuss exclusions or alternative sibling tools, but the two internal modes are well differentiated.

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 well: it gives the exact truth conditions ('verified=true ONLY when ... AND ...'), defines the leaf index and row hash, and flags what the result does not certify. It stops short of describing the full response/error shape, so it is not 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?

Three dense sentences, no filler and no restating of the tool name. The main purpose and parameters are front-loaded, and each clause (format, row path, AND condition, limitations) 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 4-parameter verification tool with no annotations and no output schema, the description covers inputs, verification semantics, dataset restrictions, and interpretation caveats. The only mild gap is that it doesn't explicitly state the output container for verified (e.g., a boolean field), though it is strongly implied by 'verified=true.'

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?

Even though schema description coverage is 0%, the description defines every input's meaning: stamp_day's format, leaf_index's 0-based row location in '/attestations/batch_<day>.tsv', and expected_row_sha256's role in the hash check. It also ties dataset to the only supported value, depin_onchain.

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 concrete verb and resource: 'Retained Merkle-membership check' for 'one depin_onchain observation', which immediately identifies its role. It also distinguishes itself from broader provenance/ledger tools by stating it verifies inclusion only and 'says nothing about Bitcoin status or upstream accuracy.'

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

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

It states the supported dataset and explicitly excludes others: 'Other datasets: unsupported (no retained proof).' The limitation 'Says nothing about Bitcoin status or upstream accuracy' also tells the agent when not to rely on this tool's result. It does not name a specific sibling alternative, but the exclusion is clear enough.

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