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

The read-only and open-world traits are already covered by annotations, and the description adds what is returned (profile and membership flags) and the batch cap. It does not describe missing-account behavior, authentication needs, rate limits, or return shape.

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

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

The description is a single front-loaded sentence with no wasted text. It is appropriately concise, though highly compressed given the parameter ambiguity.

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 three-parameter read-only lookup with no output schema, the description identifies the returned data category and batch limit. It remains incomplete on how the id/username/account inputs interact and on output details beyond the brief phrase 'profile and membership flags.'

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%, with only the account parameter documented in-schema. The description partially compensates by indicating singleton account usage and lookup by up to 100 usernames or IDs, but it does not explain precedence when multiple input modes are supplied or exact ID formats beyond the schema's note on account.

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 and content: profile and membership flags for an account, plus batch scope for up to 100 usernames or IDs. It is more specific than the title, but it does not explicitly distinguish itself from siblings such as ca_me or ca_find_people.

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

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

It implies usage for singleton or batch account lookups by specifying one account or up to 100 identifiers. However, it gives no explicit when-to-use/when-not guidance or alternatives, such as using ca_me for the authenticated user or ca_find_people for discovery.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds genuinely useful behavior: results are archive-derived (i.e. a historical snapshot, not live data) and pagination is cursor-based at up to 500 per page. It stops short of disclosing that max_pages lets a single call span up to 10 pages, or what happens when the account exceeds the archive 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 short sentences: the resource first, then the paging behavior. Nothing is redundant with the title, and 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 leaves the shape of a relation record undefined (does a follower entry include handle, ID, timestamp?). The default of one page per call is only visible in the `max_pages` schema text, so a caller could under-fetch. Adequate for a simple list tool but not fully self-sufficient.

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

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

Schema coverage is 60%; the two gaps are `kind` (enum with no description) and `limit` (bounds only). The description compensates for both by enumerating the three relation types and stating the 500-per-page cap, so it adds real meaning on top of 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 concrete resource (likes, followers, or following for an account) and its provenance (archive-derived), which an agent can map to the `kind` enum without opening the schema. It does not distinguish itself from nearby siblings such as ca_relation_overlap or ca_find_people, which is the only thing keeping it from 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 when-to-use guidance and no named alternative. An agent cannot tell from the description when to pick this over ca_relation_overlap or ca_find_people, nor any prerequisite (e.g. that the account must exist in the archive).

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 read-only and open-world profile, so the description's added value is the pagination contract — cursor-paged, max 200 per page — and the ordering/filtering defaults. It doesn't mention rate limits or whether the timeline can be truncated, which keeps it below 5, but the paging disclosure is genuinely useful beyond 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 dense sentences with no filler: the resource and ordering come first, then the optional scope, then the paging behavior. Every clause maps to a caller decision.

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-parameter read tool with no output schema, the description covers scope, ordering, filtering, and paging adequately, and the schema documents the response shape via the format enum. The omission of max_pages (multi-page retrieval in a single call) is the one behavioral element an agent could get wrong from the description 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 coverage is 80%, so the baseline would be 3, but the description adds meaning the schema lacks: it clarifies that the date range is optional and that replies and retweets are excluded via optional flags — covering the two boolean parameters that carry no schema description at all. It doesn't clarify max_pages (following multiple pages in one call), which is the least obvious parameter.

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

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

States a specific verb-and-resource pair — retrieve an account's tweets in time order — plus the scoping options (date range, reply/retweet exclusion). It implicitly separates itself from timeline-searching siblings like ca_search_tweets, but never names them, so the differentiation is inferential rather than explicit.

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 'An account's tweets' implies the use case (single-account timeline) but gives no explicit when-to-use guidance, no exclusions, and no pointer to ca_search_tweets, ca_get_tweets, or ca_thread for related retrieval tasks. Usage is inferable from the resource named, which is the definition of a 3.

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 and openWorldHint, so the safety profile is covered. The description adds genuinely non-obvious behavior: matching is fuzzy and accent-insensitive, and there is a secondary code path that falls back to a direct account lookup for non-member exact handles. It stops short of describing result ordering or how the two code paths differ in output.

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, zero filler, and the primary matching semantics are front-loaded ahead of the edge-case fallback. Nothing could be cut without losing 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?

For a search tool with no output schema, an agent still cannot tell what comes back — account objects, bare handles, or ranked matches — nor what the default `limit` is or how ambiguous matches are ordered. The two code paths (fuzzy member search vs. direct account lookup) presumably return different shapes, and that is undisclosed.

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

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

Schema description coverage is 0%, so the description carries the burden; it explains `query` well (partial name or handle, fuzzy, accent-insensitive). It says nothing at all about `limit`, which is bounded 1–50 in the schema with no documented default, so half the parameters remain uninterpreted.

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 and resource (find archive members) plus the matching strategy (partial name or handle, fuzzy, accent-insensitive), which is far more informative than the title 'Find people'. It implies a distinction from exact-lookup siblings like ca_account via the fallback clause, but never names ca_account or ca_members outright, so the boundary stays inferential.

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: reach for this when you have a partial name or handle and want a member. The fallback sentence does useful routing work by signaling that exact handles of non-members are still resolved. However, there is no explicit 'use X instead when…' guidance against the many sibling lookup tools (ca_account, ca_me, ca_members).

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 and openWorldHint=true, so safety and world-access behavior are covered. The description adds that results come from an archive and can be scoped overall or to one person, but it does not disclose that the 'scan' limit may bound how far back the earliest result can be found.

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 tight sentences with no filler, front-loading the core operation before giving concrete example questions. Every sentence contributes to understanding 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?

For a seven-parameter read-only tool with no output schema, the description covers the central intent and person-scoping behavior. However, it does not explain the roles of optional parameters like n and reply_to_user, nor does it warn that scan limits may affect the search 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?

With 57% schema description coverage, the schema already documents q, scan, since, and until. The description clarifies the word/phrase matching and the 'one person' scope, but leaves n, reply_to_user, and the scan-limit implications largely undocumented 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?

The description states a specific verb and resource: 'Find the earliest archived tweets containing a word or phrase.' It also adds scope ('overall or by one person') and a clear first-said use case, though it does not explicitly name sibling alternatives such as ca_search_tweets or ca_phrase_timeline.

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 through the questions 'when did I first say X' and 'who said it first,' which tells the agent when this tool is appropriate. It does not state exclusions or name alternative tools, so it falls short of the top score.

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, openWorldHint), so the bar is lower, and the description adds real value beyond them: results preserve request order, and missing IDs mean deleted, opted-out, or unarchived rather than a transient failure. That last point is genuinely actionable and prevents pointless retries. It does not mention error behavior for malformed refs or any rate limits.

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

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

Two tightly packed sentences: the retrieval contract first, then the failure interpretation. No filler, no restatement of the title, and the most decision-relevant constraint is 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?

No output schema exists, so the description should hint at the return shape; it covers ordering and, via the schema-covered format flag, level of detail. It omits what happens on partial failure (some IDs found, some not) and whether results preserve a distinct indicator for missing refs, which an agent calling with mixed batches would want.

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% — refs and the compact/full enum are fully documented in the schema itself, including what compact trims. The description's '1–100' restates the schema's minItems/maxItems, and 'returned in request order' concerns output rather than parameter meaning. 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 (fetch tweets) plus the two accepted identifier forms (numeric ID or x.com/twitter.com status URL) and the batch bound of 1–100. This implicitly separates it from ca_search_tweets (lookup-by-reference vs. query), 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?

The 'by ID or status URL' framing makes the usage context clear: you must already know which tweets you want. It also tells the agent how to interpret an absent result, which guides follow-up behavior. It stops short of explicitly routing keyword/author queries to ca_search_tweets or ca_account_tweets.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds that the result is scoped to the calling key and includes rate limits, which is useful context, but says nothing about failure modes (e.g. invalid/revoked key) or the shape of the limits data.

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 with no filler. Every word carries information about scope and returned content.

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 must convey what the call yields, and it names both payload elements (identity, rate limits). It is nearly complete for a trivial zero-arg tool, missing only a hint about the response structure or error conditions.

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; there are no argument semantics to explain. 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?

States a specific verb ('Show') and resource ('the calling API key's identity and rate limits'), so an agent knows exactly what comes back. It stops short of distinguishing itself from the similarly named sibling ca_account, leaving ambiguity about whether account data and key data differ.

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: an agent would call this to verify its own credentials or check remaining quota. No explicit when-to-use, prerequisites, or pointer to alternatives such as ca_account is given.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds useful pagination behavior and a 1,000-per-page maximum, but does not disclose return shape, auth requirements, or rate-limit 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?

Two compact sentences with the key resource definition front-loaded and the pagination constraint immediately after. No unnecessary text.

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 list tool, the description covers the resource and pagination basics. However, it lacks routing guidance versus sibling tools and does not describe the returned member fields, which matters because there is no output schema.

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 67%, and the description clarifies that results are cursor-paged and capped at 1,000 per page, reinforcing the limit and cursor parameters. It does not explain max_pages or add much beyond the schema's existing cursor and max_pages descriptions.

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?

Clearly identifies the resource as current Community Archive members and clarifies that these are people who uploaded their archive. It is specific enough to distinguish the resource, but it does not explain how it differs from sibling ca_find_people.

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 no explicit when-to-use guidance, no exclusions, and does not mention alternatives such as ca_find_people. Usage is only implied by the resource name.

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 and openWorldHint, so safety is covered and the description adds real value by disclosing the returned aggregates. However, it omits the critical caveat that counts are computed over a bounded 'scan' of results rather than the full corpus, which materially affects how an agent should interpret the numbers.

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 what it counts and how, followed by a single purposeful use-case hint. No filler or restatement of the title.

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 mid-level schema coverage, the description should say more about the result structure (per-bucket counts, how top authors are ranked) and about the filters and scan cap. What is present is accurate but leaves gaps an agent must guess at.

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?

At 57% schema coverage the description usefully maps the time bucketing to day/week/month/year (the enum has no schema description) and clarifies 'word or phrase' semantics for q. It says nothing about scan, since/until, from_user, or reply_to_user, leaving roughly half the parameters undocumented in both places.

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 concrete verb (count) and resource (phrase occurrences over time) plus the output shape (first/latest use, top authors). An agent can distinguish this from ca_first_said or ca_who_talks_about by the aggregation, though the description never names those siblings 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?

'Useful for tracing how an idea spread' implies a research/trend use case but gives no explicit when-to-use versus when-to-use-a-sibling guidance. There is overlap with ca_first_said (first use) and ca_who_talks_about (authors) that the description never resolves.

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 annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds valuable behavioral context beyond the annotations by specifying the receipt fields, the SHA-256 input format, and that request_id is included as provenance. It does not cover error behavior or batch semantics, but for a read-only receipt generator this is substantial 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?

The description is a single dense sentence that front-loads the core purpose and then details the receipt contents. Every clause carries useful information, including the hash format and provenance field, with no wasted text.

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 carries the burden of explaining return values, and it does so by enumerating the receipt fields and hash provenance. The single input parameter is fully documented in the schema, and annotations cover safety and openness, so an agent has enough to call 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 100%: the single refs parameter is documented in the schema as 'Tweet IDs or status URLs', and the description refers to the same input as 'tweets'. The description adds no syntax or format details beyond what the schema already provides, 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?

The description states a specific transformation: turning tweets into dated proof records, and enumerates the receipt contents (expanded links, timestamp, permalink, author, SHA-256 hash). This distinguishes it from sibling retrieval tools like ca_get_tweets because the output is a proof record, not just tweet data.

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

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

The intended use is implied by 'Turn tweets into dated proof records', but the description does not explicitly say when to choose this tool over ca_get_tweets or other siblings, nor does it state exclusions or prerequisites.

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

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

Annotations already declare readOnly and openWorld, so safety posture is covered. The description contributes useful provenance ('archive-derived edges') and names the returned metrics, but omits cost/pagination behavior implied by the 1-40 max_pages bound, which matters for a potentially expensive two-sided fetch.

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 states inputs, options, and outputs 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?

With no output schema and 50% parameter coverage, the description should explain the response shape more concretely (counts, list format) and clarify how max_pages affects results. It names the metrics but leaves the agent to guess the returned structure and depth 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 50%: 'a'/'b' and 'kind' are self-evident or enum-bounded, but 'max_pages' is undocumented in both schema and description, and the description offers no syntax or format guidance beyond what the schema gives. Baseline 3 for partial coverage where the description adds little.

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

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

The description gives a specific verb (compare) and resource (two accounts' followers/following) and even names the outputs (shared accounts, Jaccard similarity). It does not distinguish itself from the close sibling ca_account_relations, which likely also deals with follower/following edges.

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

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

No guidance on when to use this comparison tool versus the sibling ca_account_relations or ca_find_people, and no prerequisites noted beyond the vague 'archive-derived edges' provenance. An agent must infer that this is the overlap/intersection tool rather than the listing 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 read-only and open-world behavior; the description adds the all-words-must-appear search semantics and the offset pagination cap. It does not disclose authentication needs, rate limits, result ordering, or response shape, and there is no output schema.

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

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

The description is three short sentences with no wasted wording. Purpose, filters, and pagination are front-loaded and easy to scan.

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 an 8-parameter search tool, it covers the core purpose, filter dimensions, and pagination constraints, while annotations and schema handle safety and parameter details. It omits result-shape and ordering details, but the schema's format description partly covers what results look 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 coverage is high (88%) and already documents q, limit, dates, format, and filters. The description reinforces the search/filter/pagination categories and supplies useful context for the otherwise undocumented offset parameter ('pages with offset, max 5,000').

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 (search) and resource (tweets/archive) plus the key full-text constraint that every word must appear. It does not explicitly name or contrast sibling tools such as ca_account_tweets or ca_tweets_window, so sibling differentiation is only implicit.

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

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

Mentions filtering by author, replied-to user, and date, which implies when the tool is useful. However, it gives no explicit when-to-use/when-not guidance or routing to alternative sibling tools.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds a genuinely useful behavioral constraint beyond that: it returns only the author's own continuation, not all replies, which prevents a common misinterpretation of what 'thread' means here.

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 sentence with zero filler, front-loading the verb and resource and then qualifying the scope. Nothing could be removed without losing meaning.

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 three fully documented parameters, no output schema, and annotations covering safety, the description supplies enough to call it correctly. A note on result size or whether the chain is truncated would close the remaining 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 100% — the schema documents ref, the compact/full format enum, and the days_forward range. The description adds no parameter-level detail such as accepted ref forms or the 14-day forward limit, 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 specific verb ('Reconstruct') and resource ('the thread around a tweet') and defines the exact scope: ancestors above plus the author's own continuation below. That scope implicitly separates it from generic fetchers like ca_get_tweets or ca_search_tweets, though no sibling is named outright.

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

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

Usage is implied by the scope description rather than stated: an agent can infer it is the tool for thread reconstruction, but the description gives no explicit conditions, prerequisites, or when-not guidance against alternatives like ca_get_tweets.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds useful behavioral constraints: the 31-day maximum window and cursor-paged retrieval. It does not disclose rate limits, return format behavior, or what happens when max_pages is reached.

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 dense sentence with the key scope and constraint front-loaded. Every phrase adds information: the resource, the window boundary, the maximum window size, account scope, and pagination behavior.

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 covers the essential retrieval shape and window constraint, which is enough to understand the tool's purpose. However, for a six-parameter paginated query tool with no output schema, missing date format details and limit/max_pages semantics leave meaningful gaps 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?

With only 50% schema description coverage, the description must compensate but only partially does so. It explains the since/until window and the 31-day cap, but omits the date format for since/until, the meaning of limit, and how max_pages interacts with cursor paging.

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 that it retrieves archived tweets within a date window across all accounts. This distinguishes it from account-scoped siblings like ca_account_tweets and search-oriented siblings like ca_search_tweets, though it does not name alternatives 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 'across all accounts' and the date window, suggesting broad bulk retrieval rather than targeted search or single-account queries. However, there is no explicit guidance on when to prefer this over ca_search_tweets, ca_get_tweets, or ca_account_tweets.

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 and openWorldHint, so safety is covered. The description usefully adds that results are ranked by frequency and include earliest mention plus a top tweet, but it omits the behaviorally important fact that results come from a bounded scan (max 5000 tweets), which affects how complete the answer is.

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 core verb and resource, then the ranking and outputs. No filler, though 'best-received tweet' is slightly vague for a one-sentence budget.

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?

Seven parameters with under half documented in schema and no output schema, yet the description explains none of the tuning knobs. An agent could call it correctly on `q` alone but has no basis for setting scan/top or for interpreting the bounded-scan caveat.

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 only 43%, so the description must compensate for 'top', 'scan', 'from_user', and 'reply_to_user' — and it does not. 'scan' is especially opaque (it caps how many tweets are examined) and is decisive for interpreting result completeness; neither its meaning nor 'top''s is clarified here.

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 ('Find people ... authors who tweet about a word or phrase') and even previews the ranking and returned artifacts (earliest mention, best-received tweet). It does not distinguish itself from the similarly named sibling ca_find_people, so an agent could plausibly confuse the two.

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 'Find people by topic' implies a discovery/influencer-identification use case, but the description never says when to prefer it over ca_find_people, ca_search_tweets, or ca_first_said. No exclusions or prerequisites are stated.

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