VaultBags

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 declares 'Read-only public data' for the safety profile, explains that the score decomposes into protocolScore (inherited guarantees) and projectScore (token-specific track record), and warns that fresh tokens show projectScore 0. It omits error behavior, rate limits, and pagination, keeping it 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?

Front-loaded with the verb and resource, and the score-composition caveat earns its place by preventing misinterpretation of the result. The middle clause about protocol guarantees is somewhat verbose but still functional; no sentence is pure waste.

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 convey return values, and it does: Autonomy Score split into protocolScore/projectScore, plus passport (identity, surfaces, on-chain receipts) and treasury. That covers the shape of the response; only edge-case behavior (errors, missing mint) is absent.

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

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

Schema description coverage is 100%, so the base58 SPL mint format is already documented in the schema. The description only restates the parameter as 'by SPL token mint' and adds that it accepts ANY VaultBags token, which is marginal semantic value over the schema. 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 and resource: evaluate any VaultBags token as an autonomous agent by SPL mint, returning its Autonomy Score, passport, and treasury. However, it never distinguishes itself from close siblings like get_agent_passport, get_autonomy, or get_project_treasury, so an agent must infer that this is the composite view rather than a scoped one.

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 trigger is implied (look up an agent by mint) and there is one genuine interpretive guideline: never read the composite score alone for a freshly launched token. But it gives no when-to-use-vs-alternatives guidance against the many overlapping sibling tools, leaving selection 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 full behavioral burden. It does disclose the payload facets (a genuine plus given no output schema), and the noun 'passport' plus the get_ prefix implies a safe read, but it says nothing about permissions, caching, cost, or 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?

Two dense sentences with no filler, and the content enumeration is front-loaded. The final clause adds intent rather than restating the name, though the phrasing is jargon-heavy and could be tighter.

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 reasonably compensates by listing the return fields. However, it leaves the agent without guidance on when this is preferable to get_agent or get_autonomy, and without any note on safety or freshness, so it is adequate rather than complete.

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

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

The tool takes zero parameters, which is the baseline-4 case. The description adds no parameter meaning, but none is needed; there is nothing for it to clarify beyond the absence of arguments.

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 resource (the vault agent's passport) and enumerates its contents: identity, capabilities, machine surfaces (MCP/REST/OpenAPI), Autonomy Score, and on-chain decision receipt pointers. That is concrete enough for an agent to know what it retrieves, though it never distinguishes itself from the closely named sibling get_agent.

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

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

Usage is only implied by the closing clause 'Shaped so another agent can evaluate this one programmatically,' which suggests agent-to-agent discovery/evaluation. There is no explicit when-to-use, when-not-to-use, or routing versus get_agent or get_autonomy, both of which cover overlapping ground.

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 data is read-only/public and adds a genuinely useful interpretive caveat ('a low sub-score means a young track record, not a failure'), which prevents the agent from misreading output. However, it says nothing about the shape or units of the returned values, and no output schema exists to cover that gap.

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 that front-loads the primary artifact (Autonomy Score) and then the backing facts, followed by a short qualifying clause. The content list is dense but every item is a distinct returned data point, so it earns its space.

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 and no parameters, the description sensibly compensates by enumerating the returned components, which is the main thing an agent needs. The remaining gap is the unresolved relationship to get_autonomy_spec and the absence of any format hints.

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 per the rubric the baseline is 4 — there is no signature to misread. The description correctly implies no inputs are needed.

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 resource — the vault agent's Autonomy Score — and enumerates the underlying facts it returns (frozen decisions, receipts, distribution cycles, value paid, firewall status, income coverage). It does not distinguish itself from the adjacent sibling get_autonomy_spec, which a reader might reasonably confuse with it.

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 when-to-use guidance and no alternative named, despite get_autonomy_spec sitting right next to it in the toolset. The only usage-adjacent signal is 'Read-only public data', which is a property, not a selection rule.

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 burden and covers it well: it declares read-only, warns that scores are not comparable across spec versions, and discloses provenance per input ('some are anchored on-chain, one is our own assertion and says so'). It also enumerates an explicit list of what the score does NOT claim, which is unusually strong caveat 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?

Purpose and read-only status are front-loaded, and the specification of contents is dense but each clause earns its place. The opening sentence is long and run-on, which slightly hurts scannability, but nothing 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 and no parameters, the description compensates by enumerating exactly what the returned spec contains: dimension weights and scope, per-dimension formulas, source endpoints, verifiability, composite formula, tier thresholds, and disclaimers. Nothing needed to call or interpret this zero-arg tool is missing.

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

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

The tool takes zero parameters, so the baseline is 4; there is nothing for the description to disambiguate. Schema coverage is trivially 100% for an empty properties object.

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 resource (the Autonomy Score's published rules) and immediately scopes it against the sibling concept of the score itself ('so the number can be recomputed rather than believed'). An agent can distinguish this metadata/spec tool from get_autonomy without opening either schema.

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

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

It gives explicit use cases — 'to check our score yourself, or to score an agent without us' — which tells the agent both a verification and an alternative-scoring path. It stops short of stating when NOT to use it (e.g. when you just want the score value, use get_autonomy), so it is clear but not fully routing.

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, and it does much of that work: it discloses the data source (vault asset snapshots), the exact return fields, the sign convention for the edge, and that the result is 'reported either way' so lagging performance is not hidden. It does not discuss auth, rate limits, or read-only status explicitly, though 'get' and the absence of parameters make those largely inferable.

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 punchy 'The honest track record:' hook followed by the comparison, the return contents, and the sign convention. Four sentences is slightly more than needed, and 'positive means the daily line won, negative means it lagged, reported either way' is mildly redundant, but every sentence conveys usable information.

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

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

With no output schema and no annotations, the description must explain the return payload, and it does so thoroughly (cumulative returns, edge with sign semantics, day count, verdict-readiness flag) plus names the underlying data source. The only meaningful omission is its relationship to the sibling comparison tool get_shadow_vs_brain.

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 there is nothing for the description to disambiguate. The baseline for a no-parameter tool 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 precise comparison: the vault's daily Smart Allocation line vs a fixed 33/33/33 split, including what each side of the edge means. An agent knows exactly what question this answers. It stops short of a 5 because it never names or distinguishes itself from the closely related sibling get_shadow_vs_brain, leaving the agent to infer which comparison tool to pick.

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 rather than stated: the mention of 'enough history for a headline verdict' hints that this is a periodic performance-check tool, but there is no explicit when-to-use, prerequisites, or exclusion against alternatives. With get_shadow_vs_brain in the sibling list covering a parallel comparison, the absence of routing guidance is a real gap.

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 add useful context (the data is public, and the payload includes a rationale note plus weights and a receipt tx), but says nothing about auth requirements, freshness/caching, or read-only nature beyond the 'get_' prefix.

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 defines the resource and its payload with zero filler. Every clause earns its place by describing a distinct returned element.

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 must convey the return shape, and it does so by naming the market note, weights, and on-chain receipt transaction. It is nearly complete for a zero-parameter read tool, missing only freshness or auth specifics.

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 there is nothing to document and the baseline is 4. The description correctly implies no input is needed for a fixed 'today' snapshot.

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

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

Names a specific resource ("Today's public Daily Vault Briefing") and enumerates its contents: a market note, the weights, and the on-chain receipt transaction. This is clear and distinct from vague siblings, though it doesn't explicitly contrast itself with the closely related get_todays_allocation or get_monthly_reports.

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 and no alternatives named. With many siblings covering adjacent concepts (get_todays_allocation, get_vault_docs, get_monthly_reports), the agent is left to infer that this is the daily narrative snapshot rather than being told.

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 supplied, so the description carries the full burden. It does disclose useful traits: output ordering ('newest first') and a filter condition ('each day that was stamped'), implying not every day yields a record. It says nothing about read-only safety, authorization, or limits, though the read nature is strongly implied by the listing framing.

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 compact sentence that front-loads the resource and ordering before the field enumeration. No filler, though the trailing clause 'of each day that was stamped' is slightly convoluted without materially adding information.

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

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

This is a low-complexity read (one optional parameter, no nested objects) and there is no output schema, so the description correctly compensates by enumerating the returned fields. That covers the critical gap; only the missing link to sibling tools keeps it from a 5.

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

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

Schema description coverage is 100% and the single 'days' parameter is fully documented in the schema (default 14, max 30). The description never mentions the parameter, so it adds no semantics beyond the schema; baseline 3 is appropriate.

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

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

The description names a specific resource (recent daily allocation decisions) and enumerates the returned fields (date, weights, rationale, receipt transaction), so the agent knows exactly what it gets. It does not, however, distinguish itself from near-siblings like get_todays_allocation, get_treasury_history, or get_recent_cycles, so the agent must infer the boundary.

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 or when-not-to-use guidance and no named alternative. With siblings such as get_todays_allocation (current) and verify_decision (per-decision), a sentence on when history is preferred over those would have been the key differentiator.

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 so well: it declares the tool is read-only, that concentration is null rather than approximated when the scan is incomplete (a data-quality failure mode), that protocol/pool wallets are excluded, and that results are chain-derivable. These behavioral traits go well beyond what an empty schema provides.

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 purpose is front-loaded in the first clause, followed by an enumeration of metrics, boundary conditions, and a safety trait. Every sentence adds a distinct fact with no filler or repetition.

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 aggregate tool with no output schema, the description covers what data is returned, how it is bounded (no addresses, no per-wallet amounts, protocol/pool exclusions), and how failures are represented (null concentration). An agent has everything needed to decide if this tool answers a holder-distribution question.

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 there is no parameter syntax to explain and the baseline is 4. The description appropriately focuses on the return shape instead, stating which aggregates are produced and what is deliberately omitted.

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 direct framing ("Who holds the token, in aggregate") and then enumerates the exact metrics returned: distinct holding wallets, day/week change, locking wallets and locks held, and supply concentration. It also draws a sharp boundary against siblings like get_supply by defining what is *not* included (addresses, per-wallet amounts, protocol wallets, pools). An agent can tell it apart from get_lock_tier without opening the schema.

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

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

It clearly states the scope and exclusions (no addresses, no per-wallet amounts), which tells an agent what this tool is and is not for, and implicitly routes a user wanting holders' identities elsewhere. However, it does not name any sibling tool as an alternative for per-wallet or address-level queries, which 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?

No annotations are provided, so the description carries the full burden and does it well: it discloses read-only status, that the record is rebuilt by walking a wallet's full Solana transaction list (implying cost/latency), that totals are recomputed rather than stored, and that individual deposits are withheld. It stops short of stating latency or rate limits explicitly.

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?

Purpose and rug-check framing are front-loaded, followed by the return-field distinctions. It is long but most sentences carry substantive meaning for a complex tool, though the single dense paragraph could be tightened.

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

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

With no output schema and no parameters, the description compensates fully by explaining the key return semantics (lock.allLocked, builtIntoLiquidity, positionNow, feesCompounded, readAt/positionReadAt/pricedAt), what is omitted, and where the full record lives. Nothing essential to calling it correctly is missing.

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

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

The tool takes zero parameters, so the baseline is 4. The description correctly treats the tool as parameterless and instead invests in explaining the returned fields, which is the right allocation of effort.

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 and frames the exact question it answers ('can they rug this'), which is a distinct angle from siblings like get_proof_of_reserves, get_lock_tier, or get_project_treasury. An agent can tell what this tool returns and why it differs from the other liquidity-adjacent tools.

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

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

The framing 'answers the question behind can they rug this' implies the use context, but there is no explicit when-to-use-vs-alternative routing or when-not guidance. With 37 siblings, naming a comparison tool would have helped; usage must be inferred.

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 at all, the description carries the full burden and does so unusually well: it declares read-only status, states that the tier grants nothing, is never stored, and is not read by the boost multiplier. That is exactly the kind of negative capability disclosure that prevents an agent from assuming tier is a stateful or boost-affecting property.

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 mode semantics are front-loaded and efficient, but the middle sentence about on-chain creation, unlock, and the one-percent threshold is domain education that does not help an agent select or invoke the tool. A tighter version would keep the mode contract and the 'grants nothing / read-only' caveats and drop the derivation mechanics.

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, and the description compensates by describing what each mode returns (a tier, how far the next tier is, or the tier table). Combined with the behavioral caveats and full parameter semantics, an agent has enough to call it correctly; only the exact return shape (fields, units) remains 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 coverage is already 100%, so the baseline is 3, but the description adds real meaning: it explains what each parameter asks for, that they are optional and independent, and the default behavior when neither is supplied (returns the tier table). It also clarifies that size/balance is not an input, so the same term maps to the same tier at any balance.

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

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

The description identifies a specific resource (the lock tier) and enumerates the three distinct answer modes: tier for a given term, tier a wallet holds, or the full tier table. It implicitly distinguishes itself from simulate_lock_boost by noting the boost multiplier does not read this tier, though the distinguishing verb ('returns'/'reads') is only implied rather than stated.

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 usage context: use `days` to ask which tier a hypothetical term would reach, `wallet` to read a wallet's current tier, and neither to get the table, and it states the two inputs are optional and independent. What is missing is an explicit exclusion or named alternative for when an agent should prefer simulate_lock_boost 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?

With no annotations, the description carries the full behavioral burden. It does disclose meaningful traits: the return includes per-asset reads (bullish/bearish/neutral relative to gold, S&P 500 or treasuries) plus convictions and weights, and it is explicitly numbers-only with no free-text influence, implying a deterministic read operation. It says nothing about permissions, caching/refresh cadence, or whether the values are point-in-time.

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 signal inventory is front-loaded in a single dense sentence, followed by a short sentence on the per-asset reads and a framing statement on determinism. It is long but every clause names a distinct signal, so little is wasted; the enumeration could be tightened but serves a purpose.

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

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

With no output schema and no parameters, the description must describe the return surface itself, and it does so concretely by listing each signal plus the reads, convictions and weights that accompany them. It is nearly self-sufficient; only the time-scope mechanics (is 'today' fixed and when does it roll over) and any access prerequisites are 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?

The tool takes zero parameters, so there is no parameter semantics to document and the baseline of 4 applies. Nothing in the description conflicts with the empty schema, and the signal list doubles as an implicit description of the returned fields.

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 resource (quantitative market signals) and enumerates exactly what it covers: real yields, breakevens, dollar trend, gold momentum, credit spreads, VIX, S&P momentum, the 10Y, the 10Y-2Y curve and crypto sentiment. It implicitly distinguishes itself from the allocation sibling by positioning itself as the signals 'behind today's allocation,' but it never names get_todays_allocation 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?

Usage is only implied via the phrase 'behind today's allocation,' which suggests it is the diagnostic detail layer for the allocation tool. There is no explicit when-to-use statement, no exclusions, and no named alternative among siblings such as get_todays_allocation or simulate_allocation.

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 exist, so the description carries the full burden. It does add genuinely useful behavior beyond structured data: each month is committed on-chain via a Memo with the sha256 of the stored payload, making figures tamper-evident after the fact. However, it says nothing about auth requirements, pagination, ordering, or how the returned payload is shaped.

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 resource is front-loaded, which is good, but the prose is metaphor-heavy ('closed books', 'stamped', 'promises nothing') and the closing sentence is rhetorical rather than operational. Some of it earns its place by conveying tamper-evidence; the rest is decorative for an agent deciding whether to call the tool.

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 and no annotations, the description partly compensates by enumerating the fields each report contains and explaining the on-chain verification mechanism. It is fairly complete for a one-parameter read tool, though it omits return ordering, formatting, and the effect of the `months` argument.

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 `months` parameter is fully documented in the schema with range and default. The description adds no syntax, default, or semantics for it. Baseline 3 applies when the schema does the heavy lifting.

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 resource (one report per calendar month) and enumerates its contents: fees claimed, cycles run, RWA distributions, holder value claims, decisions, and earnings. An agent can distinguish this from siblings like get_daily_briefing or get_recent_cycles. It never explicitly contrasts with those siblings, but the content is distinct enough to be identifiable.

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 named alternatives among the many sibling read tools. The only routing hint is the immutability note, which describes trust properties rather than selection criteria. The agent is left to infer applicability.

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 "Read-only" claim merely restates readOnlyHint and destructiveHint=false, earning no credit. Beyond annotations it adds two genuinely useful facts: the per-wallet auth scoping shared with get_my_vault, and the result-state model (earned / still open with remaining requirement / unread). It says nothing about ordering, size, or how "what is left to earn it" is represented.

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 sentence with no filler, but it is overstuffed: the colon-and-parenthesis construction and the dangling list of criteria make the reader parse twice. Key information (per-wallet scope) is front-loaded, which helps, but the second half is dense to the point of obscurity.

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 and no parameters, the description carries the return-value burden, and it does describe the three result states plus the presence of remaining-to-earn detail. It falls short only on the ambiguous criteria list and the absence of any indication of result ordering or shape.

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

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

The tool takes zero parameters, so the schema has no semantics to explain and the baseline of 4 applies. The description correctly avoids inventing parameter talk and instead spends its words on scope and return content.

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 resource ("your badges") scoped to the signed-in wallet, which is clearer than the bare tool name. However, "badges" is never defined, and the trailing list ("holding time, claims, claimed amounts in real units, locking, the top 20 and voting") is syntactically ambiguous — it reads as either badge categories or input data, so the agent cannot form a crisp picture of what is returned.

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?

Scope is implied by "the wallet you signed in with" and the note that it uses the same sign-in as get_my_vault, which tells the agent this is a personal, authenticated read. There is no explicit when-to-use versus siblings such as get_my_claims or get_my_performance, and no statement of when not to call 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and closed-world, so safety is covered. The description adds value beyond them by disclosing the implicit wallet scoping (no address parameter) and the shared sign-in requirement with get_my_vault, plus the aggregate nature of the response — real behavioral context the annotations do not carry.

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 with the subject and scope front-loaded and the returned fields packed into a tight list; no filler, no repetition of the title, and every clause conveys new information.

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

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

There is no output schema, so the description must describe the return contents — and it does so exhaustively (count, totals, averages, lock-boost count, first/latest/largest claim). Combined with the stated auth context, nothing an agent needs to call this correctly is missing.

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

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

The tool takes zero parameters, so the baseline of 4 applies. The description still clarifies that scoping comes from the signed-in wallet rather than any input, which is the only semantic an agent could otherwise misread.

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 ('claim history in $VAULT') and immediately scopes it to 'the wallet you signed in with', then enumerates exactly what the record contains (count, total/average value at claim time, lock boost inclusions, first/latest/largest). An agent can distinguish it from get_my_vault or verify_claim without opening any schema.

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

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

It supplies a real prerequisite ('same sign-in as get_my_vault') and flags the operation as read-only, which helps the agent know the required auth context. However, it never states when to prefer this over siblings that also touch claims (e.g. verify_claim, get_my_performance), so usage is implied rather than routed.

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 cover read-only/idempotent safety, but the description adds genuinely useful behavioral context: 'Past results only, never a forecast' sets expectations about the data's nature, and it clarifies the auth requirement ('same sign-in as get_my_vault'). It stops short of describing format or refresh 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?

Front-loaded with the core purpose and the descriptive clause is information-dense rather than padded. The single long clause is slightly crowded but every element 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?

With no parameters and no output schema, the description carries the load and does so reasonably, enumerating the reported dimensions (earnings, duration, pace, lock impact) and the read-only/historical nature. Return format specifics are the only minor 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?

The tool takes zero parameters, so the schema baseline of 4 applies; there is nothing for the description to disambiguate beyond confirming the implicit sign-in scope.

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 resource ('your own $VAULT position') and what it reports (RWA earnings, duration, pace, lock impact). 'Your own ... for the wallet you signed in with' implicitly distinguishes it from the general get_rwa_performance sibling, though it doesn't name that sibling 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?

'Same sign-in as get_my_vault' and 'your own' imply usage context, and read-only framing is clear, but there is no explicit when-to-use versus when-to-use-the-alternative guidance (e.g., versus get_rwa_performance or get_my_vault).

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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description usefully adds auth context ('same sign-in as get_my_vault') and discloses the aggregate nature of the data set — useful beyond the annotations, though it says nothing about cost or latency of assembling this multi-source rollup.

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 densely packed sentence with the resource front-loaded and the default and auth notes trailing. The enumerated content list runs long but every clause names a distinct returned field, so little 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?

With no output schema, the description must carry the return-value burden, and it does by enumerating the five content blocks. The main residual gap is the relationship to overlapping sibling tools, but for a single-optional-param read tool this is nearly complete.

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

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

Schema description coverage is 100% and the month parameter's description already spells out 'current' / 'previous' / YYYY-MM within 12 months. The description only echoes the default ('This month so far by default'), adding nothing the schema doesn't already say. 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?

Opens with a specific verb-free but clear statement of the resource: 'Your month in the vault, for the wallet you signed in with', then enumerates the concrete contents (claims in units and USD, lock boost counts, ranking, badges, vault distributions). It distinguishes itself from get_my_claims and get_my_badges implicitly by being the aggregated recap rather than the raw list, though it never names those 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?

Only guidance given is the default window ('This month so far by default') and the auth hint ('same sign-in as get_my_vault'). There is no statement about when to prefer this recap over get_my_claims, get_my_badges, or get_monthly_reports, which all overlap in content — the agent must infer the routing.

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 readOnly/idempotent/non-destructive, yet the description still adds real behavioral value: 'A part that could not be read is null, never zero' discloses a failure encoding that would otherwise cause the agent to misread missing data as a zero balance. The sign-in requirement is also restated as an auth trait. It says nothing about result size, pagination, or ordering of the month-by-month series.

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 scope ('Everything you have claimed from the vault, for the wallet you signed in with'), then the content breakdown, then caveats. The middle enumeration is dense but each item maps to a distinct part of the response, and the closing two sentences carry the null semantics and auth note without padding.

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 carries the burden of describing return values, and it does: units, entry and current valuation, unclaimed amounts, and monthly totals, plus the null-vs-zero rule. For a zero-parameter, read-only tool with full annotation coverage, nothing an agent needs in order to call or interpret it is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. The wallet is implicitly supplied by the session rather than a parameter, which the description does clarify via 'the wallet you signed in with'.

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: it returns everything the signed-in wallet has claimed from the vault, broken into real units, historical vs current valuation, pending claims, and monthly running totals. The parenthetical examples (grams of gold, SPY shares, USDY) and the explicit tie to the sign-in wallet make it distinguishable from get_my_vault and get_my_claims without opening any schema.

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

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

Usage context is clear: this is the personal, sign-in-scoped timeline view, and it points at get_my_vault for the shared sign-in behavior. It never states exclusions or names a sibling to use instead for a narrower question (e.g. get_my_claims for a flat claim list), so the agent must infer the boundary.

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, idempotentHint, and destructiveHint=false. The description goes beyond them by disclosing the auth requirement (one-time wallet sign-in) and the capability boundary: that access 'cannot claim, sign, move funds or vote'. That is meaningful behavioral context, though it says nothing about caching, staleness, or failure when unsigned.

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 subject and scope, then a colon-delimited inventory of return fields, then the access caveat. Every clause carries content, though the single long sentence is dense and the second sentence could be tightened.

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

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

With no output schema, describing the returned quantities is the description's job and it does so thoroughly, and the annotation set covers the safety profile. The only gap is the absence of any routing hint against the many 'my'/'get' siblings, which matters given the crowded sibling list.

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 information because there is none to add; it implicitly confirms the wallet is derived from the signed-in session rather than passed in.

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 resource ('Your own $VAULT position') and enumerates the content returned: claimable amounts in gold, S&P 500 and Treasuries, share of holdings, locked amount, and lock boost. 'Your own' and 'the wallet you signed in with' scope it to the caller, which separates it from protocol-wide siblings like get_holder_distribution or get_treasury_stats, 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?

It states a precondition ('Needs a one-time sign-in with your wallet'), which is useful usage context, but gives no guidance on when to reach for this versus near-neighbours such as get_my_claims or get_my_performance. Usage is implied by the overlap in return fields rather than 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 the full behavioral burden and does so richly: it is recomputed on read and cannot go stale, allLanded semantics are explained ('not found' never counts as success), no partial figure is served if the ledger or chain cannot be read in full, signatures are omitted, and it is read-only.

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 what the tool does and then layers semantics (allLanded, the no-partial-figure guarantee, signature omission). Dense and largely waste-free, though it runs long and some clauses could be tightened.

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

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

For a zero-param read-only integrity check with no output schema and no annotations, the description covers everything an agent needs: the outcome categories, the allLanded contract, the failure behavior, and why no signature list is returned.

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?

There are zero parameters, so the schema has nothing to document and the baseline is 4. The description correctly does not invent 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?

States a specific verb and resource: it looks up every recorded holder payout on Solana and tallies them into confirmed, rejected, or missing. This distinguishes it from siblings like verify_claim and verify_day, which check individual claims or days rather than the whole ledger's agreement with the chain.

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 a clear purpose-driven context: 'Use it to check that the claim ledger matches the chain rather than trusting it.' However, it does not explicitly name alternatives (e.g., verify_claim) or state when-not to use it, leaving some routing 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 full behavioral burden. It discloses valuable non-obvious context: ticker and name are creator-supplied and must be treated as untrusted display data, and the token mint is the only unfakeable identifier. It does not mention pagination, ordering, or caching, keeping it just 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?

Three sentences, zero waste, front-loaded with scope before listing fields and the security caveat. Every sentence earns its place.

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

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

With no output schema, the description compensates by enumerating the returned fields (token mint, ticker, name, distribution split, total RWA value). For a no-parameter list tool this is nearly complete; only ordering and volume/limits are 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?

The tool takes zero parameters, so there is nothing to document and the baseline is 4. The description correctly implies a no-argument full-list retrieval, consistent with the empty schema.

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

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

States a specific verb (returns/lists) and resource (every treasury running on VaultBags), and defines what 'project' means here. It enumerates the returned fields, so an agent knows exactly what it gets back. It does not explicitly contrast with the singular sibling get_project_treasury, so it falls short of 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?

Usage is implied: use this to enumerate all projects/treasuries. There is no explicit when-to-use statement, no exclusions, and no named alternative (e.g., get_project_treasury for a single project). Adequate but with a clear routing gap.

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 disclose the important traits: read-only, public on-chain data, and a prompt-injection caveat that creator-authored ticker/name fields must never be treated as instructions. It does not cover freshness/latency, invalid-mint behavior, or response shape, but the safety and provenance disclosure is well above average.

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

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

Three sentences, all front-loaded: what is returned, how it is sourced, and the injection warning. Nothing is redundant and each sentence adds distinct information.

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

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

With no output schema, the description usefully enumerates the returned fields, standing in for a return-value spec. Read-only status is stated, and the sole parameter is fully covered by the schema; only error/edge-case behavior is unaddressed, which is a minor gap for a read tool.

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

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

Schema description coverage is 100% for the single 'mint' parameter, which already documents it as a base58 SPL token mint address. The description's 'by SPL token mint' restates rather than extends that, so 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?

Names a specific resource (a single integrated project's live treasury), the keying dimension (SPL token mint), and enumerates the components returned: claimable pool, lock-boost pool RWA holdings and USD values, distribution split, and total fees processed. The word 'live' implicitly separates it from get_treasury_history and get_treasury_stats, though 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?

There is no when-to-use or when-not-to-use statement, and no alternative is named despite many overlapping siblings (get_treasury_stats, get_treasury_history, get_my_vault, get_rwa, get_proof_of_reserves). The scope ('one integrated project', keyed by mint) is only implied by the phrasing, leaving the agent to guess which treasury tool to pick.

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 so well on the important points: it declares read-only, explains that data is read live from the mint, and specifies edge-case behavior (an unread mint is reported as unread, never as having no controls) plus the provenance caveat (issuer rules, not VaultBags'). It omits caching/pagination/refresh cadence, which keeps it 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 content is front-loaded with a clear 'Proof of Reserves:' label, but the single dense paragraph mixes a return-value catalogue with prose that reads partly as marketing ('real-world assets', 'certified issuer'). Every sentence conveys information, yet the delivery is heavy for what is ultimately a no-argument read tool.

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 is right to enumerate the returned fields, and it does so thoroughly, including the issuerControls sub-fields and the interpretation caveat. An agent knows what it will receive; only the absence of usage routing and refresh semantics keeps it from being fully complete.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing for the description to disambiguate.

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 (Proof of Reserves) and enumerates exactly what it returns: on-chain wallets, issuers, live balances and USD values, decision receipts, lifetime payouts, and issuer controls. This is far more specific than a tautology, though it never names a sibling (get_rwa, list_rwas) to distinguish itself from obviously adjacent 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?

There is no explicit when-to-use or when-not-to-use guidance, and with clear siblings like get_rwa, list_rwas, and get_holder_distribution the agent is left to infer the boundary. The description explains content but not selection criteria.

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 disclose meaningful behavioral detail: the numbers are "live, receipt-backed," and every section exposes the URL where it can be verified. It omits any auth/caching/rate context, but for an obvious read-only aggregator the verification-provenance disclosure is substantive.

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 oversized sentence padded with branding ("The Meter:", "the daily brain's on-chain decision receipts") and a long inline enumeration. It is front-loaded with the core purpose, but a list of five-plus metrics inside one sentence is harder to scan than it needs to 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?

There is no output schema and no annotations, so the description must describe the return surface, and it does so section by section, including the verification URL per section. It is largely sufficient for a zero-parameter read tool, with only fallback/limitation behavior 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?

Zero parameters, so the baseline of 4 applies. The description correctly spends no effort on parameter semantics and instead describes output content.

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: returning one consolidated snapshot of the protocol's live, receipt-backed numbers, then enumerates the sections (treasury value, pipeline throughput, decision receipts, x402 earnings, locked supply). It is clearly distinguishable as the aggregate read, though it never explicitly contrasts itself with siblings like get_treasury_stats or get_supply.

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?

Calling it "one consolidated snapshot" implies the intended use case (grab everything at once rather than fanning out to individual endpoints), but the description never says when to prefer this over the many sibling reads, nor any prerequisites. Usage is implied rather than 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 the full burden and does so: it declares the tool read-only, discloses that it returns aggregates only and not entries, explains the time-weighted ticket mechanics (buying at the close yields no tickets, locked tokens count), and states that the beacon round is emitted only after the list is frozen so the number cannot be known in advance. That is unusually rich behavioral context for a read 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 what-it-returns summary is front-loaded in the first sentence, and the follow-on sentences each add decision-relevant information (weighting, beacon, totals-only, frozen-list alternative). The mechanical explanation of ticket weighting and beacon timing is longer than strictly needed for invocation, which keeps this short of a 5.

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

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

No input parameters, no annotations, and no output schema, so the description must supply everything an agent needs, and it does: field inventory, semantics of the numbers, fairness/integrity guarantees, read-only status, and where the detailed data lives instead. Nothing material 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?

The tool takes zero parameters, which is the baseline-4 case; there is nothing for the description to disambiguate. It does not discuss defaults or scoping arguments because none exist.

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?

Opens with a precise verb+resource ('The public state of the holder raffle') and then enumerates the exact fields returned: open/closed status, window, weighted ticket total, wallet count, prize, and claim grace period. Nothing in the sibling list overlaps, and an agent can tell exactly what this tool produces without opening a schema.

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

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

It clearly frames when the tool is the right source ('This returns totals only') and explicitly routes the agent elsewhere for per-wallet detail ('Once entries close, the frozen list ... is published at /api/raffle/entries?drawId=<id>'). It stops short of stating prerequisites or the inverse condition (e.g., what to call before entries close), so it is clear context rather than a full when/when-not rule set.

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 and does well: it discloses that only counts, never wallets, are returned; that `truncated` means a window is a floor rather than a total; and that the operation is read-only. It stops short of describing rate limits, caching, or exact return shape, keeping it at 4.

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 and the returnable metrics, then caveats. Dense but nearly every clause adds information (the trader-count rule and truncation semantics earn their place). Slightly long but not padded.

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

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

No output schema exists, so the description must explain returns, and it does: field list, the deduplication rule, and the truncated-floor caveat. For a zero-parameter read tool this is nearly complete, though it could note the response structure more explicitly.

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 per the rubric the baseline is 4. There are no inputs whose semantics need elaboration.

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 and enumerates the exact metrics returned (trades, buys, sells, distinct buyers/sellers/traders), including the non-obvious rule that traders is not buyers plus sellers. It also positions itself relative to siblings by explaining the activity is what funds the vault, distinguishing it from treasury stats/history.

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 through the treasury-funding framing and the 24h/7d windowing, which helps an agent infer when this is relevant. However, there is no explicit when-to-use or when-not statement naming alternatives such as get_treasury_stats or get_recent_cycles.

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 the shape of the returned data (SOL processed, whether all swaps succeeded, per-cycle transaction receipts), implying a read-only operation, but says nothing about freshness, ordering, caching, or auth/permission requirements.

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 clauses, front-loaded with the resource and followed by the returned fields. 'The protocol's heartbeat, machine-readable' is slightly ornamental but does convey scannability, so little 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?

For a single optional-parameter read tool with no output schema, the description compensates well by naming the fields a cycle contains. Missing only freshness/ordering context, which is a minor gap given the tool's simplicity.

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 'limit' parameter is fully documented in the schema, including its default of 5 and range. The description adds no syntax or format detail beyond the schema, so 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 the resource clearly (the latest distribution cycles across every integrated project) and enumerates the returned fields (SOL processed, swap success, on-chain transaction receipt), which is specific enough to distinguish it from siblings like get_recent_activity or get_treasury_history. It lacks an explicit verb, but the retrieval intent is 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?

There is no guidance on when to call this versus the many adjacent monitoring tools (get_recent_activity, get_todays_allocation, get_protocol_meter, get_treasury_history). The 'protocol's heartbeat' framing hints at a broad health-check use case but never states conditions or 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?

No annotations exist, so the description carries the full burden, and it does disclose key behavior: what is returned (verified identity, on-chain price/24h/market cap/liquidity, oracle price for equities) and an important caveat that premiumPct comes from an executable Jupiter quote only 'when available'. It omits auth requirements, rate limits, and error behavior for unresolvable symbols.

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 action and accepted inputs, then the return payload, then example use cases. The long first sentence is dense and list-heavy, but with no output schema every enumerated return field earns its place; only minor tightening is possible.

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 and no annotations, the description compensates well by describing the return payload in detail and giving usage scenarios. It is essentially complete for invocation; only peripheral details (failure modes for unknown symbols, freshness/latency of the live market data) are absent.

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

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

Schema coverage is 100%, so the baseline is 3, but the description earns more by supplying concrete accepted inputs (HOODx, NVDAx, AAPLx, USDY, GOLD) that clarify the symbol-vs-mint duality and the kinds of assets in scope (tokenized equities, treasuries, commodities).

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 ('Look up one tokenized real-world asset by its symbol ... or exact Solana mint') and immediately enumerates the payload categories (certified identity, live market read, oracle price / premium). The word 'one' implicitly separates it from list_rwas, and the identity/price framing separates it from performance-oriented siblings like get_rwa_performance.

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 concrete triggering questions ('how is tokenized Robinhood doing', 'is HOODx trading above the real stock') and a stated purpose ('resolve the real mint safely'), which is strong positive guidance. It stops short of naming alternatives or stating when not to use it (e.g. vs list_rwas for discovery), so it lands just below the top band.

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 reasonably well: it discloses data provenance ('reconstructed from actual on-chain swaps') and scopes the metric to the vault's own purchases rather than live market data. It doesn't explicitly state read-only status or confirm no side effects, but for a zero-parameter read tool the provenance disclosure adds genuine value.

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 purpose and the returned metrics before the clarifying comparison. The parenthetical asset examples are compact, and nothing 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?

With no output schema, the description must convey return values, and it does list them (cost basis, average cost, current value, return, in USD and SOL). For a simple no-param read tool this is nearly complete, with only minor gaps around format or empty-data behavior.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No parameter-level detail is needed or missing.

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 ('vault's REAL position performance per RWA') and enumerates what it returns: cost basis, average cost, current value and return in USD and SOL. It explicitly distinguishes itself from market price history, letting an agent separate it from siblings like get_rwa and list_rwas.

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 closing clause 'Distinct from an asset's market price history: this is how the vault's own buys have done' gives clear context for when this tool is the right choice. However, it doesn't name a specific alternative tool to route to, and gives no exclusions or prerequisites beyond that positioning.

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 usefully discloses negative constraints — it never chooses assets, amounts, wallets or timing — and explains when the `say` field is null versus populated, which is genuine behavioral context. It still omits return structure, permissions, and any freshness/pagination behavior, so it is helpful but incomplete.

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 identity is front-loaded ('The shadow analyst scoreboard'), which is good, but the first sentence is a very long run-on and the `say` explanation is dense and jargon-heavy. Every clause is roughly relevant, but readability and structure suffer.

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, no annotations, and zero parameters, the description must convey the return shape. It gestures at the `say` field's structure ({ share, capPoints } and the 23-43% band / capPoints rule) but never lays out the overall response, so an agent knows the concept yet not the full payload. 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 takes zero parameters, so the baseline is 4. There are no parameters whose semantics the description could add to, and it correctly does not invent any.

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

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

The description identifies a specific resource — the shadow analyst scoreboard — and states exactly what it compares (an LLM's daily allocation call vs. the deterministic model alone and an even split). An agent can grasp what the tool yields. It does not, however, differentiate itself from the closely related sibling get_brain_vs_flat, which appears to cover a similar comparison, so the 'vs' framing is not fully disambiguated.

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 when-to-use or when-not-to-use guidance, and no alternative is named (e.g., 'use get_brain_vs_flat for X instead'). The usage is only implied by the content description. An agent must infer the call context itself.

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 "Read-only, aggregate only," that strategies are signed selections frozen on-chain, and that presets run as verifiable paper strategies. It stops short of describing pagination, ordering, or any auth requirement, but the behavioral profile is substantially richer than 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?

Front-loaded with the scope statement, then layered domain context. Four sentences, each contributing meaning, though the on-chain/paper-strategy explanation is slightly expansive for a definition whose main job is routing and return shape.

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 and no annotations, so the description must explain what comes back – it does, listing asset list with base weights, adopting tokens, and today's frozen decision when present. Combined with a clear domain gloss, an agent has enough to call and interpret it, with only minor gaps (ordering/pagination) remaining.

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 per the rubric the baseline is 4. There is nothing to document and the description adds no misleading parameter claims.

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 clear verb+resource ("Every vault strategy") and precisely delineates scope: the four named presets plus each project-frozen distinct strategy. An agent can tell it is the aggregate list vs. a single lookup, though it never names the sibling get_strategy 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?

Usage is implied by "Every vault strategy" and "aggregate only," which signals the list/overview case. However, it never states when to prefer this over get_strategy or get_todays_allocation, nor any exclusions, so guidance is only inferable.

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

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

No annotations are provided, so the description carries the full burden. It discloses the read-only nature ('Read-only') and describes the shape of returned data well, but says nothing about permissions/auth requirements, pagination, or limits on the 'recent daily decisions' window.

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 dense sentences with no filler; the resource and its scope are front-loaded, followed by the identification options and read-only note. Every clause carries information.

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

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

With no output schema, the description compensates by enumerating the returned fields (asset selection, adopting tokens, per-day weights, convictions, memo receipts). This is nearly complete for a read tool; only auth/limits and the definition of 'recent' are omitted.

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

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

Schema description coverage is 100% and there is a single parameter, so the schema already documents the preset-id/64-hex-key input. The description restates the same accepted values (classic, growth, hard-money, income) without adding format or validation detail beyond the schema, warranting the baseline 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?

States a specific verb (get) and resource (one vault strategy) and explicitly scopes it as the singular in-depth view, contrasting with the plural sibling get_strategies. The returned content is enumerated (signed asset selection, adopting tokens, daily decisions with weights/convictions/memo receipts), so an agent can tell exactly what this 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 phrase 'One vault strategy in depth' implies this is the single-strategy detail tool versus the list-oriented get_strategies, and it explains how to identify the target (preset id or 64-hex key). However, it never explicitly states when to choose this over get_strategies or any exclusions, leaving usage 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 full burden, and it delivers: it discloses read-only status, that there is no team/investor/private-sale allocation, and precisely what each figure includes and excludes (pool-held tokens counted vs. excluded). It omits only return format/response shape, which keeps it from 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?

Purpose is front-loaded and every sentence carries real meaning, but the phrasing is conversational ('both of the numbers that legitimately carry that name, because picking the wrong one silently produces a wrong percentage'), which is longer than the content strictly requires. Still an efficient, well-ordered definition overall.

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 must define what comes back, and it does so fully, explaining both supply figures, their inclusion rules and their intended consumers. Nothing an agent needs to interpret the result is missing.

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

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

The tool takes zero parameters, so the baseline is 4. The description does valuable semantic work on the returned values (defining marketSupply vs. distributedSupply), but since there are no input parameters to disambiguate, no deduction is warranted.

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 (return the token's supply) and goes further by naming the two distinct supply figures it returns. None of the sibling tools (get_liquidity, get_holder_distribution) overlap, so an agent can distinguish it immediately.

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

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

Explicitly routes the agent: use marketSupply for market-cap questions, distributedSupply for holder-share/leaderboard/lock-boost questions. This is a rare case of naming when to use each returned value and why the alternative is wrong.

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 and no output schema, the description carries the full burden, and it does credibly enumerate the returned fields, including conditional ones ('if already stamped') and the frozen-for-the-day state. However it says nothing about freshness, determinism, permissions, or what happens when today's allocation isn't yet computed, leaving behavioral edges undisclosed.

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 leads with the primary output (buy proportions) and appends secondary fields. It is dense but every clause maps to a distinct return value, so little 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?

For a zero-param read tool with no annotations and no output schema, the description covers the return payload well enough that an agent knows what it will receive. Minor gaps remain around freshness and the not-yet-stamped/not-yet-computed cases, but the core is complete.

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

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

The tool takes zero parameters, so there is no parameter semantics to document; baseline 4 applies. Nothing in the schema requires description-level compensation.

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 resource (today's RWA buy proportions) and enumerates its components (gold/S&P 500/treasuries, band, frozen flag, rationale, receipt). This distinguishes it from general siblings like get_rwa and from simulate_allocation. It stops short of explicitly contrasting with the closest sibling (simulate_allocation / get_decision_history), so it lands at 4.

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 'Today's' (this is the point-in-time read, not the historical get_decision_history or the hypothetical simulate_allocation), but the description never states when to use it vs those alternatives or any exclusions. No explicit routing guidance is provided.

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

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

With no annotations, the description carries the full burden and does well: it declares read-only, clarifies it is descriptive history 'never a projection,' and explains the even-spread sampling semantics that materially affect interpretation. It omits auth/permission requirements and any rate or size caveats, keeping it from 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?

Front-loaded with the payload contents, then sampling behavior, then the trend framing and read-only caveat. Efficient overall, though the all-caps emphasis and some restatement ('what was held and what it was worth') add slight 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?

Only 2 optional params, no output schema, and no annotations, so the description must establish return shape and safety — which it does (field list, sampling, read-only). It is nearly complete, with only minor gaps around response envelope or pagination limits.

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 defaults, min/max, and meanings for days and points are already documented in the schema. The description's sampling explanation reinforces how points are distributed across days but adds no syntax or format detail beyond that. 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 resource (treasury history) and enumerates the returned fields: per-sample total USD plus gold, S&P 500, and US treasuries balances/values. This distinguishes it from point-in-time siblings like get_treasury_stats without needing to open either schema.

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

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

Explicitly frames itself as 'THE tool for reasoning about trend instead of a single moment,' which signals the when-to-use condition against snapshot alternatives. It does not name the alternative tool or state exclusions, so it stops 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, the description carries the full behavioral burden and does so: it declares 'Read-only' and clarifies subtle metric semantics (holdersCount/$VAULT vs protocolHoldersTracked/all-projects, activeLocks vs uniqueLockers non-interchangeability). This is genuinely useful beyond a bare read hint, though it omits any freshness/caching or rate-limit context.

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 resource name and then builds field-level disambiguation. Dense but every clause (holders vs protocol holders, lock contracts vs lockers) earns its place, and the 'Read-only' tag closes cleanly.

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 and no annotations, the description must explain returns itself, and it does so thoroughly – effectively serving as a prose output schema. It is nearly complete for a no-arg read tool, missing only freshness/pagination context.

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

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

The tool takes zero parameters, so there is no parameter meaning to convey; baseline for a no-param tool is 4. The description appropriately spends its words on return-field semantics instead.

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 ('Live treasury statistics') and enumerates exactly what it returns (per-asset balances/USD values, vault value, holder payouts, fee totals). The 'Live' qualifier implicitly separates it from the sibling get_treasury_history, but no sibling is named explicitly, so it falls short of 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?

There is no statement of when to use this tool versus alternatives such as get_project_treasury or get_treasury_history. The contrast with history is only implied by the word 'Live', leaving selection guidance 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 supplied, so the description carries the disclosure burden. It adds one genuinely useful trait — that the content is 'condensed' and includes 'links to the live surfaces' — but does not state that it is a static read-only reference, how large the payload is, or what format the docs come in. For a documentation fetch this is adequate but thin.

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 front-loaded sentence with no filler: the resource, its condensed nature, and the covered topics all land immediately. Nothing could be cut without losing routing information.

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

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

With no output schema, the description must characterize the return, and it does by naming the covered topics and noting links to live surfaces. It is complete enough for an agent to decide to call it, though it leaves the exact response shape 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate beyond what the (empty) schema already conveys. Baseline 4 applies; no parameter context is expected or missing.

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 (retrieves condensed protocol documentation) and enumerates the topics it covers — the 70/20/10 distribution, Smart Allocation, locking, claiming. It is obviously distinct from the data-returning siblings like get_my_vault or get_supply, though it never names a sibling explicitly to route the agent.

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

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

Usage is only implied: the topic list (framing concepts plus links to live surfaces) suggests it should be consulted for protocol background rather than live figures. There is no explicit when-to-use, no when-not-to-use, and no pointer to any alternative tool for those topics.

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 declares the data is read-only reference data, explains the authenticity guarantee (mints proven against the issuer's own domain), and disclaims it as non-advice. It omits whether any auth is needed, but the safety and provenance profile is clearly conveyed.

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

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

Three sentences, front-loaded with the resource definition before the optional filtering and scope caveats. The first sentence is dense but every clause (issuers, examples, authenticity) earns its place; minor redundancy in the closing caveats.

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 annotations and no output schema, the description adequately covers what the tool returns (registry entries whose mints are verified) and its scope limits. Return-shape detail is light, but nothing critical for correct invocation is missing.

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

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

Schema coverage is 100% with enum values and per-parameter descriptions, so the schema already does the heavy lifting. The description only restates that filtering by category or issuer is available, adding no syntax or format detail beyond the schema.

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

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

States a specific resource (openly transferable tokenized real-world assets on Solana) with concrete examples (tokenized gold, US Treasuries, equities/ETFs) and names the issuers covered. It is clearly a listing endpoint distinct from the singular get_rwa, but it never names that sibling 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?

Notes that category/issuer filtering is optional and clarifies scope with 'not limited to what the vault itself holds', which implicitly routes agents away from vault-holdings tools. However, it does not explicitly say when to use this versus get_rwa or get_rwa_performance, leaving the choice 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?

With no annotations, the description carries the full burden and does so: nothing can be signed or spent, the image, fee share, initial buy and all signatures stay with the person, invalid fields are refused with a reason, and the submitted text is shown verbatim to the person before anything happens. That is exactly the mutation-safety disclosure an agent needs.

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

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

Three sentences, front-loaded with the action, then the inputs/outputs, then the safety envelope. Dense but every sentence carries information; the final two clauses about review are somewhat repetitive with the earlier no-signing statement.

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 must describe the return — it does (launcher link plus next steps). With no annotations it also covers the safety and failure profile, leaving nothing an agent needs missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description goes beyond it by naming the required trio and flagging website and X account as optional, and by signaling that server-side launch rules can reject a field — a constraint the schema only implies through maxLength.

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 ('Draft a Bags token launch with VaultBags preconfigured') and immediately scopes it as draft-only ('for a person to finish and sign'). This cleanly separates it from every sibling, which are all read-only getters/verifiers.

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

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

Clear about when to use it and what the handoff looks like: gather name/ticker/description, receive a launcher link plus next steps for the person to sign. No alternative tool is named, but no sibling competes for this job, so the missing exclusion is minor.

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 determinism ('same inputs always give the same weights'), the hard output bounds (23-43% band), the neutral treatment of omitted inputs, and the non-advice disclaimer. It stops short of stating permissions, error behavior, or that the operation is side-effect free beyond the implied 'simulate' framing.

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 tight sentences, front-loaded with purpose before mechanics, and each clause carries information (output shape, bounds, default handling, determinism, disclaimer). Slight overlap between 'always within the 23-43% band' and the determinism sentence keeps it from a perfect score.

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 10-optional-parameter compute tool with no annotations and no output schema, the description usefully compensates by spelling out the returned shape (proportions, convictions, rationale) and the bound/default behavior. It is adequate; only edge cases (invalid ranges, error responses) are unaddressed.

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

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

Schema coverage is 100%, so the per-parameter meanings are already documented and the baseline is 3. The description adds genuinely new semantics: all ten inputs are optional, any subset is accepted, and missing values default to neutral — behavior the schema does not express.

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 verb+resource ('Run the vault's allocation model on YOUR market inputs') and names the exact outputs (buy proportions for gold / S&P 500 / treasuries, per-asset convictions, rationale). The word 'simulate' plus 'YOUR market inputs' clearly separates it from siblings like get_todays_allocation (actual allocations) and get_market_signals (current data), so an agent can route without opening the schema.

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

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

Gives solid invocation guidance ('all inputs are optional numbers; provide any subset and the rest are treated as neutral'), which tells the agent how to call it. However, it never states when to use this simulation versus get_todays_allocation or get_market_signals, nor any exclusions, so the when-to-use decision is left 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?

With no annotations the description carries the full load and does so well: live data, the exact formula source (the payout cron), the 1.5x cap, and the critical semantic that the multiplier is global so locking more spreads the boost rather than raising the number. The 7-day eligibility rule is also disclosed. This is unusually complete behavioral context.

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 action and its outputs. The "Honest by construction" sentence is longer than needed but earns its place by preempting a likely misconception. No filler, though it could be tightened.

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

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

No annotations or output schema exist, so the description must explain the return values itself, and it does (percentage locked, multiplier, projections for both). Combined with the constraint disclosure and optional-input behavior, an agent has everything needed to call and interpret it.

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 param is already documented, so the baseline is 3. The description adds meaning by explaining the optional amount drives the projected state ("what both become if you lock N more tokens"), clarifying the param's purpose beyond the schema text.

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 ("Estimate the lock boost") with concrete outputs enumerated: current locked percentage, the global multiplier, and the projection with N more tokens. It is clearly distinguishable from siblings like get_lock_tier (static tiers) and simulate_allocation (different simulation target).

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 operating context: it simulates current state or a hypothetical lock, and notes the 7-day minimum lock requirement to earn boost. It does not name an alternative or state when to prefer another tool, so it stops short of explicit routing.

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 and does so richly: it enumerates the exact returned artifacts, specifies the memo string format, names the required treasury signer, and states the trust model ('the guarantee is on-chain, not this response'). This is far beyond structured-field coverage.

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

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

Front-loaded with purpose and return contents; every sentence is substantive given the absence of an output schema. It runs long and the verification-procedure sentence is dense, but nothing is wasted or 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?

No output schema exists, so the description must describe returns — and it does, itemizing the committed record fields, the Merkle proof, the day's root, and the memo. It also explains how to independently validate them, which is the whole point of the tool.

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

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

Schema coverage is 100% and there is a single parameter; the schema already documents tx as the base58 Solana signature. The description restates 'the claim's Solana transaction signature' without adding syntax or format detail, so 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 precise verb+resource: verify one holder claim against the on-chain Merkle root, scoped by a Solana transaction signature. This clearly separates it from verify_day (day-level) and get_my_claims (enumeration) even without naming 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?

Implied usage is clear from the required tx input — use it when you hold a claim's transaction signature and want to prove inclusion. But there is no explicit when/when-not guidance and no mention of alternatives like verify_day or get_payout_integrity.

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, and it does: it states no transaction is needed, enumerates exactly what is returned (leaves, live-recomputed root, Solana-stamped root, match flag, anchoring transaction, signing treasury wallet), and explains where the real trust guarantee lives (on-chain memo format, signed by a fixed treasury wallet, landed after the day ended). This is unusually 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?

Front-loaded with the core purpose and scoping constraint before the alternative and the verification recipe, and every sentence carries information. The final sentence is dense and long, packing the memo format, signer, and timing constraint into one clause chain, but it is not padded.

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

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

There is no output schema, so the description must (and does) enumerate the return payload, and it additionally supplies the independent verification procedure an agent would otherwise lack. For a one-parameter verification tool this is complete.

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

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

Schema coverage is 100% and the schema already documents the period format and omission behavior, so the baseline is 3. The description adds genuine meaning to the omission ('audit the most recent stamped day, which makes it suitable for continuous monitoring'), going beyond the schema's terse 'Omit for the latest stamped day.'

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 ('Verify a whole day of the claim ledger against its stamped Merkle root') and immediately distinguishes itself from the sibling: 'verify_claim answers whether one payout is in the ledger; this answers whether the ledger itself is intact.' An agent can pick correctly without opening either schema.

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

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

Explicit when-to-use is given ('Omit the period to audit the most recent stamped day'), including a rationale ('suitable for continuous monitoring'), and the alternative verify_claim is named with the condition that selects it. Nothing is left 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?

With no annotations, the description carries the full burden and does: it labels the tool read-only, enumerates what the response contains (payload, recomputed hash, stamped hash, anchoring transaction, signing wallet), and flags a critical caveat — 'The guarantee is on-chain, not this response' — with the exact memo format and signature requirements to check independently. It also warns that a decision stamped after the day it governs is a backfill.

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 purpose and the enumeration of returned fields, then the verification contract. Every sentence is substantive, though the canonical-serialization instruction is dense and could be tightened. Slightly long but 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 and no annotations, so the description must explain return values and safety on its own — and it does, listing the payload contents, both hashes, the anchoring transaction, and the signing wallet, plus the on-chain guarantee condition. Nothing an agent needs to call and interpret this correctly is missing.

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

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

Schema description coverage is 100% and the single parameter is self-documenting ('UTC date as YYYY-MM-DD. Omit for today.'). The description refers to 'the date' as part of the committed payload but adds no format or defaulting detail beyond the schema, so 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 and resource: 'Verify one daily allocation decision against the hash stamped on-chain that day.' That scope cleanly separates it from siblings like verify_day (whole day), verify_claim, and get_decision_history (retrieval rather than verification). An agent can select it without opening any schema.

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

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

The description makes the intent clear ('Proves the decision published is the decision stamped, before the vault acted on it') and even prescribes the manual verification procedure. However, it never names when to prefer this over verify_day or get_decision_history, nor states any preconditions or exclusions. Usage is strongly implied but not explicitly routed.

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