Tabularium

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

Goes well beyond the readOnlyHint/openWorldHint annotations: discloses the $0.01 USDC-on-Base x402 price, that payment settles before execution, that a free probe call rejects calls that would fail, and that results verify offline against a public key from /menu. These are exactly the operational facts an agent needs before spending money.

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?

Price and payment protocol are front-loaded, which is good, but 'Full signed history and current values, verifiable offline' is immediately repeated in the next sentence, and there is a stray double period ('..'). Roughly a quarter of the text is 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?

With no output schema, the description does describe the payload (signed history plus current values, offline-verifiable against /menu's public key) and covers the payment handshake. Adequate for a one-parameter paid export, though it could say whether the export is paginated or bounded for large histories.

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 is already fully documented in the schema ('Only entries after this seq'), and the description's 'returns only newer entries' restates it with slightly different wording rather than adding semantics. With 100% schema coverage, the baseline 3 applies.

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

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

States a specific verb (export) and a precise resource (the paying wallet's persistent key-value store: full signed history plus current values), with the added qualifier that the output is offline-verifiable. It implicitly distinguishes itself from read-only siblings like tabularium_read by emphasizing backup/proof of the complete signed chain, but it never names an alternative explicitly.

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 use cases ('for backup or proof') and a concrete invocation protocol: call once unpaid to learn the price, then retry with params._meta["x402/payment"]. What's missing is explicit routing versus siblings such as tabularium_read or tabularium_snapshot_fetch for partial reads.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description adds genuine context beyond that: the response is a signed head with seq + hash and explicitly contains no values, plus state and expiry. However, "Free" is repeated and never defined (free of cost? free of charge tier?), leaving an ambiguity the annotations do not resolve.

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?

Extremely short, but the opening "Free. Free:" is duplicated waste and pushes the actual payload description to the back. Terseness here is under-specification rather than efficiency; the fragment does not front-load what the tool does.

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

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

For a read-only, single-parameter tool with annotations and no output schema, an agent still needs to know what a "head" represents, what "state" and "expiry" mean, and why to choose this over the sibling read/export tools. None of that is present, so the definition is not sufficient to invoke confidently in a multi-tool namespace.

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 carries the burden for the single wallet parameter. It only says "a wallet's workspace," which implies the wallet selects a workspace but never states that it is a 0x address or how it maps to state/expiry. The regex in the schema defines format, but the semantic link between wallet and returned head is left implicit.

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

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

The description names the resource ("signed head (seq + hash, no values), state and expiry for a wallet's workspace"), so an agent can infer it returns a compact commitment rather than full data. But there is no verb ('get'/'fetch') and the leading "Free. Free:" fragment obscures the actual purpose. It does not distinguish itself from siblings like tabularium_read or tabularium_snapshot_fetch.

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 statement of when to call this versus tabularium_read (full values) or tabularium_snapshot_fetch. The phrase "no values" hints at a lightweight-verification use case, but the agent must infer that routing decision itself. No prerequisites or exclusions are given.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is known. The description adds that the menu is free and discloses that each call entry includes price, payee, network, policy, and signing key, which is useful context for a sensitive field. It still omits whether the signing key is secret/redacted or whether auth is required, so a 3 is appropriate with annotations present.

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?

It is a single compact sentence, 'Free.' is front-loaded, and the field enumeration is non-redundant. The telegraphic fragment style makes the action less clear than a full sentence, but nothing is 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?

With zero params and no output schema, the description must carry the burden of explaining the return shape. It lists key fields but not the collection structure or whether the response is a catalog/list, and it leaves the signing key's exposure ambiguous. Adequate but with clear gaps.

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

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

The tool has zero parameters, so the baseline is 4 by the rules. Schema coverage is 100% and there are no parameters to explain, so the description loses nothing by not adding parameter semantics.

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

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

The title and the field list ('Prices, payee, network, policy... and the signing key for every call') imply a catalog or menu of available calls, but the description never states a verb such as 'returns' or 'lists'. It distinguishes itself from the CRUD siblings only implicitly by naming pricing/policy metadata rather than data access.

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 when-to-use guidance, no prerequisites, and no mention of alternatives among tabularium_read, head, export, write, renew, or snapshot_fetch. 'Free.' is the only contextual signal, and it does not route the agent to this tool over the others.

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

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

Beyond readOnlyHint/openWorldHint the description discloses price ($0.002 USDC on Base via x402), that charges only occur on success, the 404-for-missing-key behavior with no charge, and the 90-day post-term grace period. That is exactly the kind of cost and failure-mode context annotations cannot express.

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

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

The core purpose is buried behind the pricing preamble, and charge conditions are restated three times ('Paid ($0.002...', 'A missing key returns 404 and is not charged', 'Charged only if it succeeds'). There is also a stray double period. It is informative but not tight.

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

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

With no output schema, the description usefully characterizes the return (latest value plus its signed chain entry) and the error case. Payment mechanics are covered, though the conflicting placement of the payment parameter relative to the schema leaves a gap.

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 single 'key' parameter is fully documented with a pattern and example, so the description adds little there. It does introduce params._meta["x402/payment"], which is not in the schema (and conflicts with additionalProperties: false), making that mention more confusing than clarifying.

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?

Specific verb+resource: 'read the latest value for a key from the paying wallet's persistent key-value store, with its signed hash-chain entry.' Sibling differentiation is implicit (the name and 'read' clearly separate it from tabularium_write/tabularium_head), but no sibling is named explicitly.

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 concrete operational context: reads work during the 90-day grace period, a missing key returns 404 and is uncharged, and the agent should call once unpaid to get the price then retry with a payment payload. It stops short of stating when to prefer tabularium_head or tabularium_snapshot_fetch instead.

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

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

Annotations only say readOnlyHint=false and openWorldHint=true; the description adds the exact price and chain ($0.25 USDC on Base, x402), that settlement happens before execution, the pre-check that refuses a doomed paid call, and the failure mode for wallets with no workspace. These are genuine behavioral facts an agent cannot get from the annotations or 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?

Price and scope are front-loaded, which is good, but the pre-check rule is stated twice ('A free pre-check rejects a wallet with no workspace before any charge..' and '(a free check refuses a call that would fail)'), and there is a stray double period. Roughly a quarter of the text is 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 zero-parameter paid mutation, the description covers price, settlement order, preconditions, and retry protocol, and no output schema exists to defer to. The remaining gap is the return value — it does not say whether the caller gets the new expiry timestamp, a receipt, or any confirmation.

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 zero properties, so baseline is 4. The description goes further by documenting the out-of-band payment carrier params._meta["x402/payment"], which is not represented in the schema at all — a real addition, though the schema's additionalProperties:false makes that instruction appear inconsistent with the declared input contract.

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 (extend/renew) and two concrete resources: the workspace and the paying wallet's persistent key-value store, both for 30 days from the later of now or expiry. It is unmistakable against siblings (export/head/menu/read/write/snapshot_fetch), though the phrasing 'Extend the workspace... Agent memory: ...' leaves the relationship between the workspace and the KV store slightly implicit.

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

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

It gives an explicit invocation flow: call once without payment to get the price, then retry with params._meta["x402/payment"]. It also states a precondition ('a free pre-check rejects a wallet with no workspace before any charge'). It stops short of stating when a caller should renew versus let a workspace lapse, but the payment protocol guidance is unusually actionable.

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?

Goes well beyond the annotations by disclosing price ($0.005 USDC on Base, x402), the billing rule (charged only for 2xx text pages, refused URLs free), and exactly what the signed record contains and that it verifies offline. That is strong context for a tool with no output schema. It loses a point for the duplicated billing sentence and for not covering failure modes other than refusal.

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 price and purpose, which is the right ordering, but the billing clause is stated twice back-to-back ('refused URLs cost nothing.. Charged only if it succeeds'), including a stray double period. That redundant sentence does not earn its place and slightly muddies an otherwise compact 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?

With no output schema, the description correctly carries the return-value burden: page text, final URL after redirects, fetch time, status, and body/text hashes. Payment protocol and billing conditions are also covered. Only error behavior beyond refused URLs (rate limits, timeouts, non-text content) is left unstated.

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 url and max_chars are already fully documented, and the description adds little about them beyond restating that the signature covers what is returned. It does introduce the out-of-schema payment parameter params._meta["x402/payment"], which is real added meaning, but the mechanism is described as a retry step rather than as a parameter.

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

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

States a specific verb and resource — 'Fetch a web page as text, with a signed record' — and names the payload precisely (readable text plus an Ed25519-signed record). It does not explicitly differentiate itself from the closest siblings tabularium_head and tabularium_read, so an agent must infer that 'head' is headers-only and 'read' is something else.

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 payment workflow is spelled out clearly: 'Call once without payment to get the price, then retry with params._meta["x402/payment"]', which is genuinely actionable invocation guidance. However, there is no guidance on when to choose this over tabularium_head or tabularium_read, and no stated prerequisites such as supported content types or URL restrictions beyond the schema pattern.

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?

Goes well beyond the sparse annotations (readOnlyHint=false, openWorldHint=true): price ($0.003 USDC on Base, x402), that the first write opens a 30-day workspace, 64 KB value cap, hash-chained Ed25519 signing verifiable offline, and that failed writes are not charged. These are exactly the mutation-cost and data-durability facts an agent needs before a write.

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?

Payment and price are front-loaded, which is right, but there is duplication: 'failed writes are not charged' is repeated as 'Charged only if it succeeds', and the append-to-workspace idea is restated in the 'Agent memory' sentence. A stray double period also signals it was not edited down.

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

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

For a paid mutation with no output schema, the description covers cost, payment handshake, durability, integrity, size limits and failure charging. What it omits is what a successful call returns (hash? version? workspace id?) and whether overwriting an existing key is allowed or creates a new version — a notable gap on a self-described append-only hash-chained store.

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 already 100%, so the baseline is 3; the description adds real value by disclosing an additional transport parameter, params._meta["x402/payment"], that the caller must supply on retry and that the schema does not contain. The 64 KB restatement is redundant with maxLength but the payment parameter is genuinely beyond-schema information.

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

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

States a specific verb and resource: 'Append a value under a key in the paying wallet's workspace', with scope tied to the paying wallet. The sibling set (read, head, export, snapshot_fetch) is clearly differentiated by the write/append framing and persistence semantics.

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 the concrete invocation protocol — 'Call once without payment to get the price, then retry with params._meta["x402/payment"]' — and names the primary use case (agent memory across restarts and hand-offs). It stops short of stating when to prefer this over tabularium_read/head or how it relates to the workspace lifecycle siblings like renew.

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