CryptoSocials

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

The description adds non-obvious behavioral details: 'Group pages do not limit counts' clarifies pagination semantics, and 'multi-asset groups overlap' explains overlapping group membership. It also explicitly states that no sentiment or performance score is inferred, which prevents misinterpretation. Annotations already declare readOnlyHint=true and destructiveHint=false, and the description is consistent with these.

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 three terse sentences with no fluff. The primary action and grouping options are front-loaded, followed by two crucial behavioral notes. Every sentence earns its place, making it highly efficient for an agent to parse.

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

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

Despite having 16 parameters and no output schema, the description does not explain the return format, pagination behavior beyond the group-page note, or any filter semantics. It covers the core purpose but leaves agents without crucial details on how to construct queries or interpret results, making it incomplete for a tool of this complexity.

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

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

With 44% schema description coverage, the description carries only minimal parameter meaning. It mentions grouping by day, author, or asset, which maps to the group_by enum, and clarifies multi-asset overlap, but it does not explain filters like chain_ids, asset_type, evidence_class, or exclude_post_types. The description adds little beyond the schema for most of the 16 parameters.

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

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

The description clearly states the tool counts filtered posts and groups them by day, author, or asset, with a specific verb and resource. It distinguishes itself from retrieval tools like get_posts by emphasizing aggregation, but it does not explicitly name alternatives or contrast with similar aggregation tools like compare_activity or get_engagement_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?

No explicit guidance is given on when to use this tool versus siblings. The description implies it is for counting/aggregation, but it never states conditions, exclusions, or mentions alternatives such as get_posts for raw data or compare_activity for comparative analysis. An agent would have to infer usage from the tool name and schema.

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 mark it read-only, and the description adds useful behavioral context beyond that: 'full-window stored' clarifies the read scope, 'zero baseline is undefined' warns about division-by-zero cases, and 'Does not infer sentiment or equal collection coverage' sets expectations about limitations. No contradiction with annotations.

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

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

Two sentences with no filler: the first states the function and scope, the second states the output and key caveats. Every clause adds information an agent needs.

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

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

Given the complex nested schema and no output schema, the description covers the essential inputs and output semantics. Minor gaps remain around exact response shape and how limit/cursor relate to 'full-window' counts, but 'full-window' implies the counts are not paginated and the agent has enough to invoke the tool correctly.

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

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

Top-level schema descriptions are absent, so the description must compensate; it does by explaining the core relationship between baseline and current ('two UTC periods with identical filters') and what is computed. The nested schema already documents individual filter fields, and the description adds the 'identical filters' constraint that is not otherwise explicit.

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

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

The description names a specific verb ('Compare'), a clear resource ('stored post and author counts'), and a distinctive scope ('across two UTC periods with identical filters'). This is enough for an agent to separate it from siblings like aggregate_posts or get_posts without needing to open 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?

The description clearly establishes when to use it: period-over-period comparison of stored counts. It does not explicitly name alternative tools or state when not to use it, but the context is unambiguous and no misleading guidance is present.

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 provide readOnlyHint=true, destructiveHint=false, and openWorldHint=false. The description adds meaning by limiting scope to 'readable stored evidence' and clarifying that it returns counts and evidence-presence indicators rather than full history. This is useful context beyond the annotations, though it omits details like response shape or pagination.

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 with zero filler. The first sentence states the action, scope, and expected output; the second is a crisp exclusion. Information is front-loaded and every word earns its place.

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

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

For a read-only summarization tool the description is clear, but it lacks an output schema and does not explain the shape of the response beyond vague categories. With 12 parameters and many filters, the description could benefit from noting how filters combine or what the result structure looks like.

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 58%, and many parameters have detailed schema descriptions (date_from/to, chain_ids, asset_type, multichain, evidence_class, exclude_post_types). The tool description adds no extra parameter-level information; its mention of 'fixture/embedded evidence' and 'engagement-checkpoint presence' maps to existing schema concepts. Baseline 3 applies because the schema carries the documentation burden.

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

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

The description uses a specific verb ('Describe') and resource ('readable stored evidence in a required UTC window'), and enumerates output categories (counts, fixture/embedded evidence, engagement-checkpoint presence). It differentiates by stating what it is not (complete source history or live collection watermark), though it does not explicitly name sibling tools.

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

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

The description conveys when to use the tool (for a high-level description of archived evidence in a time window) and provides an explicit when-not ('Not complete source history or a live collection watermark'). It lacks named alternative tools, so it stops short of a full 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?

Annotations already establish readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds one useful behavioral caveat ('No current quote or candle curve is implied') which prevents misinterpretation of the output. However, it does not disclose other behaviors such as pagination, limits, or response format, so it only partially supplements the annotations.

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

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

The description is two sentences with no filler, front-loading the main function first. The second sentence clarifies a critical limitation (no quote/candle curve). This is effective and efficient, though the brevity comes at the cost of contextual completeness.

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

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

Given the tool's complexity (19 parameters, nested objects, no output schema), the description is far too sparse. It only mentions the broad output categories (identity, posts, activity counts) and one exclusion, but does not explain the many filter options, mode differences, cursor pagination, or projection levels. An agent with only this description would have significant uncertainty about how to use the tool correctly.

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

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

Schema description coverage is only 58%, meaning many of the 19 parameters lack explanatory text. The description adds no parameter-level guidance whatsoever. Given this low coverage, the description should compensate by explaining key parameters like asset_id, date ranges, mode, or filters, but it does not, leaving agents to rely on a partially documented schema.

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

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

The description states a specific verb ('Read') and a specific resource ('asset identity, compact posts and whole-window activity counts'), which clearly conveys the tool's scope. The additional sentence clarifying that no current quote or candle curve is implied helps distinguish it from price-related siblings like get_price_context and get_market_history, though it does not explicitly name alternatives.

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

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

The description provides no guidance on when to use this tool versus other siblings, nor any conditions for choosing it over alternatives like get_posts or get_author. It lacks both explicit when-to-use and when-not-to-use instructions, leaving the agent to infer selection criteria from the tool name and vague description.

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 establish read-only semantics. The description adds a little beyond that by noting the latest profile and compact posts with whole-window counts, but it does not explain pagination, continuation behavior, or output-shape considerations. No contradiction with annotations.

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

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

One tight sentence with no filler, front-loading the action and core outputs. It is efficient for what it includes, though slightly too compressed for a tool with 19 parameters.

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 19-parameter tool with no output schema, a one-line description is not complete: it does not specify return layout, how whole-window counts relate to paginated posts, or how to request non-compact output. Schema parameter descriptions help, but 42% of parameters still lack schema documentation and the description does not fill that gap.

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

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

Schema description coverage is only 58%, and the description gives almost no parameter-level guidance. Required fields like author_id and date range are not clarified beyond the name, and several schema-undocumented parameters (text, limit, cursor, has_media, post_types, author_ids) remain unexplained.

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

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

The description uses a clear verb ('Read') and names specific resources: author identity, latest stored profile, compact posts, and whole-window counts. It does not explicitly contrast with sibling tools like get_posts or search_authors, so it stops short of full differentiation.

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 resource focus on 'author' implies this is the right tool for author-centric reads, but there is no explicit when-to-use guidance or exclusion of alternatives. Given 19 siblings, a sentence on when to prefer this tool over search_authors or get_posts would materially help.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable interpretive context beyond annotations: it includes missing/failed observations, warns that observation times differ from publication, and explicitly says null counters are not zero. This prevents a common misinterpretation of missing data as zero.

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, both informative, with the core action front-loaded and no filler. Every clause adds value: the 'including missing/failed observations' clarifies scope, and the final sentence provides a critical interpretation guard. This is a model of concise, effective description.

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

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

For a read-only tool with no output schema, the description covers the most important semantic caveats (null vs zero, timing differences, missing observations) that an agent could not infer from the name or schema. It does not describe the response shape or pagination behavior, but the schema provides limit/cursor expectations, so the gap is minor. Overall, sufficiently complete for correct invocation.

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

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

Schema description coverage is 0%, and the description does not mention any of the three parameters (post_id, limit, cursor) by name or add meaning to them. It only implies the post association via 'a post’s', leaving limit and cursor entirely unexplained while the schema provides no help either. The description fails to compensate for the undocumented parameters.

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

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

The description uses a specific verb+resource ('Read a post’s stored engagement checkpoints') and adds a distinguishing detail ('including missing/failed observations') that separates it from sibling tools like get_post or get_live_summary. The scope is clear: historical engagement observations, not live or aggregate views.

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

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

The description implies when to use the tool: when you need stored, historical engagement observations rather than live or summary data. It does not name alternative tools explicitly, but the context ('Observation times differ from publication') signals that this is for checkpoint history, not current state. No exclusions are stated, but the usage context is clear.

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

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

Annotations already mark the call read-only, and the description goes beyond them by clarifying what is returned (bounded members, pins, saved-query references), that truncation is explicit, and that saved-query execution is absent. This adds meaningful behavioral context without contradicting the annotations.

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

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

Two sentences with no filler: the first fronts the core read behavior, and the second adds two relevant caveats. Every clause earns its place.

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

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

For a low-complexity tool with annotations covering read-only and non-destructive behavior, the description conveys what the return payload covers and flags truncation. With no output schema, a little more detail about response shape or truncation mechanics would make it fully complete, but nothing essential is missing for calling it correctly.

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

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

With schema_description_coverage at 0%, the description needed to explain list_id but does not mention it at all. The only implicit link is 'a List', which does not compensate for the lack of detail about how the parameter identifies the resource or any constraints beyond the UUID pattern.

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 ('Read') and a specific object: a List plus its bounded author/asset members, pins, and saved-query references. It also draws a clear boundary by noting saved-query execution is not implemented here, which helps separate it from execution-style or query-style sibling tools.

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

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

The read purpose is clear, and the saved-query caveat gives a useful when-not signal. However, the description never names an alternative tool for executing saved queries and gives no explicit conditions for choosing this over related tools such as list_lists or query_list_activity.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds substantial behavioral context: pending/unavailable means no valid summary, counts cover full adjacent windows, only the leading 30 groups are returned, and the caller must not infer complete source coverage or a live feed. No contradiction with annotations.

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

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

Four dense, non-redundant sentences with the purpose front-loaded and every caveat earning its place. There is no filler or repetition of schema fields.

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?

Behavioral caveats and count/truncation semantics are well covered, and there is no output schema to fill in return-shape details. However, the unexplained expected_input_stamp parameter and the unstated output shape leave an incomplete picture for an agent.

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

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

Schema description coverage is 0%, and the description does not explain either parameter. view_id is somewhat inferable as the Live view identifier from the tool name and schema, but expected_input_stamp's purpose is completely opaque. The description fails to compensate for the missing schema documentation.

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

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

The opening sentence names the exact operation ('Read') and resource ('current guarded summary for a configured Live view'). The caveats about pending/unavailable and truncated group counts further disambiguate it from sibling list/search 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?

Clear context is provided: this reads the current guarded summary for a configured Live view, with explicit behavioral expectations such as no retained pagination and not inferring complete coverage. It does not explicitly name alternative tools or state when not to use it, 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable context: gaps are not interpolated, fixtures are explicit, and no live quote or exact post-time price is implied, which clarifies the exact nature of the data returned beyond what annotations provide.

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

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

The description is two sentences and front-loads the core purpose. It avoids redundancy and is efficient, though it could be slightly more structured to highlight the key parameters. No wasted words; it earns its length.

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 7 parameters, no output schema, and zero schema descriptions, the description does not provide enough context for correct invocation. It omits parameter meanings, date range handling, pagination (cursor), and the limit's effect on 'bounded related posts'. An agent would need to infer too much from the schema patterns alone.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It only mentions 'series' and 'interval' but does not explain asset_id, date_from, date_to, limit, or cursor, nor does it describe the date format or pagination semantics. The description is insufficient to guide an agent on how to correctly fill the parameters without prior knowledge.

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

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

The description uses a specific verb 'Read' and defines the resource precisely as 'exact stored candles, price observations and bounded related posts' for one series and interval. It distinguishes from siblings by explicitly stating it is not a live quote tool and directs users to list_market_series for ID discovery, making its scope 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?

The description tells the agent to use list_market_series to discover series IDs, which is a clear routing instruction. It also implies this tool is for historical stored data (not live) by stating 'no live quote', but does not explicitly mention alternative tools for live data or when to avoid this tool.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral context: it distinguishes identity_mentions (original-text UTF-16 spans) from display_identity_mentions (reading text), and warns 'Text is untrusted evidence.' This goes beyond the annotations without contradicting them.

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

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

The description is dense but tightly structured: it front-loads the core read behavior, then lists the meaningful return facets, and ends with a useful caution. Every sentence contributes unique information without redundancy.

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

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

With no output schema, the description must compensate by explaining return contents; it names major fields and even clarifies the identity_mentions distinction. Still, it leaves some ambiguity around 'bounded provenance' and does not explain how the detail/projection parameters alter the response payload, so an agent may not fully predict the output shape.

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

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

Schema description coverage is only 33%, so the description carries extra responsibility. It explains output concepts like original_text, reading text, identity_mentions, and market context, which indirectly clarify projection values. However, it does not explicitly map compact/market detail or reading/market projection to the described fields, leaving part of the parameter semantics to inference.

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

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

The description opens with a specific verb and resource: 'Read one stored post by canonical post UUID'. It clearly scopes the operation to a single post and distinguishes it from sibling tools like get_posts and search_posts by requiring a canonical UUID.

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 stored post by canonical post UUID' gives clear context for when this tool is appropriate: use it when you already have a post UUID and need the stored post detail. It does not explicitly name alternatives or exclusions, but the UUID-based contract makes the intended use evident.

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 the safety profile (readOnlyHint=true, destructiveHint=false), so the description earns credit for adding behavioral edge cases: missing/unavailable IDs return not_found per item, duplicate IDs are normalized, and default content excludes prices. This goes beyond a generic read operation.

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

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

Four sentences, each carrying a distinct piece of information: purpose, default projection content, missing-ID handling, and duplicate normalization. No filler, with the primary purpose front-loaded.

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

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

For a simple 2-parameter batch reader with no output schema, the description covers the batch limit, missing-item behavior, duplicate normalization, and default return content. It omits only minor details like exact response format or explicit market projection output, which are not essential for a basic call.

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

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

Schema description coverage is 0%, so the description must clarify the parameters. It identifies post_ids as the batch input and describes what the 'reading' projection returns, but it does not explain the 'market' projection's output. It adds some meaning beyond the schema but does not fully compensate for the coverage gap.

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

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

States a specific verb ('Read'), a defined resource ('selected post IDs'), and a batch scope ('up to 50 ... in one batch'). This clearly differentiates the tool from the singular sibling get_post and from aggregate/search 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 'in one batch' phrasing implies the intended use case: reading many known IDs at once. The default reading vs. market projection hints at routing price-related queries elsewhere, but no sibling is named explicitly and no exclusion criteria are stated, leaving boundary decisions to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description necessarily adds value beyond them. It does so by specifying that exact decimals, source post, provider/series, and fixture labels are retained, which informs the agent about data granularity and composition. It also clarifies the tool is not for candles or live quotes. There is no contradiction with the annotations, and the added behavioral context is meaningful.

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

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

The description is two sentences long, front-loaded with the core action and resource. The second sentence succinctly adds data granularity details and exclusions. There is no fluff, repetition, or unnecessary information. Every phrase earns its place, making it highly efficient and well-structured.

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

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

This is a read-only tool with 5 parameters, no output schema, and pagination hints from limit/cursor. The description explains what data is retained (decimals, source post, provider/series) but does not describe the response structure, pagination behavior, or how to use the cursor. Given the absence of an output schema, the description should provide more context about the returned data and iteration mechanics. It covers the essence but leaves meaningful gaps for an agent unfamiliar with the tool.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameter meanings. The description only refers to 'asset' and 'capture-time window' in general terms, which maps to asset_id and date_from/date_to but adds no detail about format, semantics, or the pagination parameters limit and cursor. The schema provides types and patterns but no descriptions, leaving the agent to infer parameter roles from names alone. This is insufficient for the coverage gap.

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

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

The description clearly identifies the verb 'Read' and the resource 'stored USD capture observations for an asset' with a time window. It explicitly differentiates from alternatives by stating 'Not candles, live quotes, or a selected price winner,' which distinguishes it from sibling tools like get_market_history, get_live_summary, and others. This is a specific, non-tautological purpose.

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

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

The description gives explicit exclusions ('Not candles, live quotes, or a selected price winner') which implicitly guide the agent away from this tool for those use cases. However, it does not name any specific alternative tool, leaving the agent to infer which sibling handles those scenarios. This is stronger than no guidance but lacks the direct 'use X instead' clarity that would merit 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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description goes beyond annotations by explaining that all keys share the account allowance and that the current call is recorded only after its result is prepared, which is useful timing/accounting context. This does not contradict the read-only annotation since it describes system bookkeeping rather than client-facing mutations.

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

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

Three dense sentences, each earning its place: the main purpose and exclusion, the account-wide allowance context, and the timing nuance. The most important information is front-loaded with no filler.

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

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

For a simple read-only tool with two optional parameters and no output schema, the description covers purpose, scope, account-level behavior, and a subtle timing detail. It could be slightly more complete by indicating pagination behavior, but the essential context for correct invocation is present.

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

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

Schema description coverage is 0%, and the description does not mention the limit or cursor parameters at all. While the parameter names and schema constraints (default, max, min) are somewhat self-explanatory, the description adds no pagination semantics or guidance, so it fails to compensate for the schema's lack of descriptive 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?

The description opens with a specific verb and resource: 'Read account operation receipts and recorded research-credit costs.' It also explicitly excludes 'the client conversation,' which distinguishes it from potential sibling confusion and clarifies its scope.

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

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

The description gives clear context for when this tool is relevant: reading usage receipts/credit costs, not conversation content. It adds an important account-level condition ('All keys share the account allowance') but does not name specific alternative tools or state when-not-to-use conditions beyond the conversation exclusion.

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 mark the tool as readOnly and non-destructive, and the description adds useful behavioral context: it explicitly states that human seen positions are not advanced and nothing is modified. The ordering guarantee is also disclosed. No contradiction with annotations exists.

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

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

The description is two short sentences with no filler. The core action and ordering are front-loaded, and the non-modification guarantee directly follows. Every sentence adds value.

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

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

The tool is simple, annotations cover safety, and the purpose is clear. However, there is no output schema, no parameter explanations, and no guidance on pagination behavior or when to choose a sibling tool. The description is minimally adequate but leaves meaningful gaps for correct invocation at scale.

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

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

Schema description coverage is 0% and the description does not explain the 'limit' or 'after_id' parameters. The phrase 'ordered by UUID' weakly implies that after_id is a cursor, but the agent is left without explicit pagination semantics, defaults, or how the parameters interact.

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

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

The description uses a specific verb and resource: 'Read your current List directory', and adds an ordering detail ('ordered by UUID') plus an explicit non-modification guarantee. This distinguishes it from siblings like get_list and query_list_activity.

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

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

The description states what the tool does but gives no explicit guidance on when to use it versus alternatives such as get_list or list_live_views. No exclusions, prerequisites, or selection criteria are provided, so an agent must infer usage from the name and purpose alone.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable context by warning that returned data may not be fresh and must be inspected before comparing activity—information not derivable from the annotations or schema.

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

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

Two sentences, no filler, with the core purpose front-loaded and the caveat placed right after. Every word adds value and the structure is easy to parse.

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

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

Given this is a no-parameter read-only discovery tool with no output schema, the description covers the essential context: what is returned, what it is not, and a freshness caution. Nothing significant is missing for an agent to invoke it correctly.

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

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

The tool has zero parameters and the schema coverage is effectively 100%, so there is no parameter documentation burden. Per the baseline for zero-parameter tools, the description is adequate without adding parameter-level detail.

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

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

The description uses a specific verb and resource: 'Discover configured Live views, their time windows and rule versions.' It clearly identifies the tool's output scope and distinguishes it from 'customer Lists,' which is especially useful given the sibling list_lists tool.

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

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

It explicitly states what this tool is not ('These are not customer Lists') and gives actionable guidance for a common use case ('inspect returned freshness before comparing activity'). This exclusion plus behavioral caution tells an agent when to prefer this over list-oriented siblings.

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

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

Annotations already declare the tool read-only and non-destructive. The description adds meaningful behavioral context beyond that: sources remain separate, results are limited to stored data, and there is no consolidated best-price or live representation. This helps set expectations about what the tool returns.

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

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

The description is two short sentences with no filler. The core operation and scope are front-loaded, and the behavioral caveat about separate sources and no live/best-price claim is stated economically.

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

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

The description is adequate for a moderately complex list tool: it states inputs at a high level and the kind of data returned. However, with no output schema, it leaves gaps around response shape, pagination behavior, and what exactly a 'source' entry looks like.

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

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

Schema description coverage is 0%, so the description must compensate. It partially does by clarifying that asset_id is an exact asset and date_from/date_to form a UTC window, but it does not explain limit or cursor, or describe how pagination and source/interval filtering work.

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

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

The description uses a specific verb and resource: 'Find stored price sources and available candle intervals'. It also scopes the operation to 'an exact asset and UTC window' and explicitly differentiates the tool by stating it makes 'no best-price or live claim', separating it from live and aggregated price tools.

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

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

The description clearly indicates when to use this tool: when you need stored price sources and available candle intervals for a precise asset and UTC range. It also communicates exclusions by saying the tool makes no live or best-price claim, though it does not name sibling alternatives explicitly.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds valuable behavioral context: the 'without duplication' deduplication behavior and the 'Retained paging requires unchanged filters, limit and List revision' caveat, which are not captured by annotations. This goes beyond the baseline and helps the agent understand paging constraints.

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

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

The description is two sentences with no filler. The primary purpose is stated first, followed by a critical paging constraint. Every word adds value, and the structure is front-loaded. It is appropriately concise for a tool with a rich schema.

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

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

This is a complex tool with 19 parameters, many documented in the schema, and no output schema. The description provides the core purpose and a paging caveat, but it does not explain the different retention modes (explore vs exhaustive), the time window limits, or the meaning of 'compact' in context. However, since the schema carries detailed parameter semantics, the description's role is to guide high-level usage. It covers the essential differentiator but leaves the agent to infer deeper behavior from the schema, making it adequate but not 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 58%, so the schema carries much of the parameter documentation. The description does not explicitly explain any parameters; it only mentions 'compact' which maps to the detail parameter. Given the moderate coverage, the description does not need to compensate heavily, and the schema already describes modes like 'explore' vs 'exhaustive', filters, and projection. 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 states a specific verb ('search') and resource ('compact post activity in your List'), and adds a distinguishing feature ('matching its author OR asset members without duplication'). This clearly separates it from generic search tools, though it does not explicitly name a sibling alternative. The mention of 'compact' hints at a mode but relies on the schema for full meaning.

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

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

No explicit guidance on when to use this tool versus alternatives like search_posts or get_posts. The description does not mention any exclusions, prerequisites, or context where another tool would be more appropriate. The only implied usage is that it operates on a List, but this is not elaborated.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral context by warning that results may include unknown or merged states and that identity should not be inferred from a symbol alone—something not present in the schema or annotations. This goes beyond the basic read-only profile.

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 with no redundancy. The core function is front-loaded, and the caveat about symbol inference is placed second, giving it appropriate emphasis without bloating the description.

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

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

The purpose and the key caveat are clear, and the read-only annotation covers the safety profile. However, there is no output schema, and the description does not explain pagination behavior or what fields a candidate object contains. For a resolution tool that returns ambiguous/merged states, more detail about the result shape would make it more 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 0%, so the description must carry the semantic load. It does clarify what query accepts (name, symbol, canonical key, contract key), which is valuable. However, it provides no explanation for the limit and cursor parameters, which are left to inference from their names.

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

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

The description uses a specific verb ('Find') with a clear resource ('asset candidates') and enumerates the matching criteria (name, symbol, canonical key, exact stored namespaced contract key). It differentiates this from get_asset by emphasizing candidates rather than a single asset, so an agent can tell this is a resolution/search tool.

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

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

The description gives an implicit sense of when to use the tool—when you need to resolve asset candidates by the listed keys. The explicit caution 'Never infer identity from a symbol alone; unknown/merged states remain explicit' is a useful usage directive, but it does not compare against sibling tools or state when not to use this tool.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. Description adds genuine value: name matches may be historical, and returns canonical IDs for filtering purposes. No contradiction with annotations.

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

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

Two tight sentences with purpose front-loaded in the first. The second sentence adds return-purpose and a historical-match caveat. Zero filler words; every clause earns its place.

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

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

Complete for a read-only search tool: covers search criteria, return purpose, and caveats. No output schema exists, so per rules return values needn't be detailed. Minor gap is lack of explicit pagination/limit behavior, but schema defaults cover 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 description coverage is 0%, so the description must compensate. It does explain the query parameter's accepted formats (user ID, handle prefix, display name), which is valuable. However, limit and cursor pagination semantics are not addressed, and the description never names the parameters explicitly.

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?

Clear verb ('Find') + resource ('readable author candidates') + search criteria (platform user ID, handle prefix, stored display name). Distinguishes itself from get_author (fetch specific) by signaling discovery/filtering intent.

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

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

Description implies usage context — search to obtain canonical IDs for filtering — but never explicitly contrasts with siblings like get_author or search_posts. No when-not-to-use 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?

Annotations already mark the tool read-only, and the description adds meaningful behavior: it works only on stored data, makes no live provider requests, and returns a specific shape (text previews, canonical IDs, metrics, asset identities). It also clarifies that market detail is the only path to price context. No contradiction with annotations.

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

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

The description is three tight sentences with no filler. It front-loads the core action and scope, then supplies the return shape and the key alternative, making every sentence earn its place.

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

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

For a complex 18-parameter tool with no output schema, the description provides a useful compact summary: what is searched, what is returned, and how to opt into price context. It leans appropriately on the rich schema for filter and pagination semantics, though it could have briefly mentioned the text/filter search breadth for full completeness.

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

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

Schema coverage is 61% and the schema already documents most parameters in detail, including mode, order, detail, chain_ids, projection, and evidence_class. The description adds little beyond a high-level mention of 'price context' and the bounded UTC window, so it stays near the baseline without significantly compensating for undocumented parameters.

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

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

The description opens with a specific verb and resource ('Search stored posts') and adds the bounded UTC window scope. It also distinguishes itself from get_post and signals that no live provider requests are made, making the tool's role clear even among many siblings.

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

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

The description gives actionable routing: use get_post for retained detailed evidence and set detail=market for price context. It also states a clear boundary ('No live provider requests'), which helps select this tool over live-data siblings, though it does not exhaustively contrast every sibling.

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