SocialToAI

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

The annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false. The description adds useful behavioral context beyond the schema: the call is free, the purchase link requires no sign-in, and for_scripts explains how to obtain an API key. No contradiction is present.

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

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

The description is dense and front-loads the tool's purpose, but the long semicolon-heavy sentence and cryptic references like 'repeat purchase.display' reduce clarity. It is mostly efficient, yet some fragments feel awkwardly compressed.

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

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

With no parameters and no output schema, the description carries the burden of explaining return values and does so: identity, plan, balance, spend, limits, purchase link, and API-key guidance. The main residual gap is sibling differentiation from account_watch, but the core account-status context is complete.

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

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

The tool takes zero parameters, so parameter semantics are inherently minimal. The description appropriately focuses on what the no-argument call returns rather than overexplaining inputs.

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 establishes that this tool returns account identity and status, plan, credit balance, spend, limits, and purchase/API-key context. It is specific about the resource, though it does not explicitly distinguish itself from sibling tools such as account_watch.

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 stated contents—checking account standing, balance, and limits—but there is no explicit when-to-use guidance, no exclusions, and no named alternatives. It also does not clarify how this differs from account_watch.

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

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

Beyond the readOnly/openWorld/idempotent annotations, it discloses genuinely useful traits: server-side execution, quote-before-run for costly jobs, max_cost_credits refusal semantics, and that a handle re-read is free. The disclosure is delivered in compressed fragments and relies on opaque tokens (error.fix, billing.display) that an agent must resolve elsewhere, which keeps it short of a 5.

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

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

The purpose is front-loaded, which is good, but the 14-platform credit table with three figures each is bulky and largely redundant given the tool quotes its own price before a costly run. The telegraphic, article-dropping style ('What a set of accounts published lately') saves bytes at the cost of readability.

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 six-parameter, no-output-schema tool, the description covers what comes back (recent posts plus outperforming posts), cost and confirmation behavior, link formatting, and error handling. Nothing critical is missing, though the return shape is sketched rather than specified and the billing/error indirection is unexplained.

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

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

Schema coverage is 100%, so the schema already carries scale, window, confirm, max_cost_credits, and handle semantics; the baseline is 3. The description adds one real constraint not in the schema — 'Pass links whole, as given' — but otherwise mostly restates cost behavior already encoded in confirm and max_cost_credits.

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

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

The description names the resource (a set of accounts' recent posts) and the distinctive analytic angle (posts that did clearly better than each account's usual), which separates it from plain listing siblings like user_posts or account. It never explicitly contrasts with siblings such as account, watch, or brand_buzz, so the differentiation is inferable rather than stated.

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

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

Usage is only implied: the phrasing 'a set of accounts' and the multi-platform credit table signal batch account monitoring, but there is no explicit when-to-use, when-not, or named alternative among the many siblings. The only operational guidance is procedural ('Pass links whole, as given', 'On error, follow error.fix').

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 (readOnly, openWorld, non-destructive, not idempotent), yet the description adds real behavior the schema cannot: server-side execution, background runs for long jobs, a full per-platform/per-scale credit table, the billing.display notice, and that a `handle` re-read is free. What is missing is any note on latency expectations beyond 'long', or why the call is non-idempotent despite the free re-read path.

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

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

Purpose and output shape are front-loaded in sentence one, with pricing detail after. The credit table is long and its semicolon/dash notation is dense, but every line carries decision-relevant cost data. Slightly over-stuffed for a description, though not padded.

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

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

For a 9-parameter, 1-required tool with no output schema, the description covers what comes back, what it costs, how plan-vs-execute resolves, and how to handle failure and billing messages. The only real gap is the absence of any sibling routing cue, which context conditions make more important given a crowded toolset.

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

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

Schema coverage is 100%, so the schema already defines every parameter and baseline is 3. The description nevertheless adds genuinely new meaning by mapping scale × platform onto credit prices, which lets an agent choose `scale` and `platforms` on cost grounds rather than guessing. The 'medium/large not offered' dash cases are not explained.

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 first sentence names a specific resource (brand/product sentiment) and enumerates the concrete outputs: attitude shares, top mentions, top-engagement posts with source links. That is far more specific than a tautology. It never names a sibling, though, so an agent must infer the split from 'research', 'trending' and 'search' on its own.

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 procedural guidance exists — costly or long runs quote a price first, `confirm` controls plan-vs-run, and errors route to error.fix — which is genuine when-to-run mechanics. But there is no statement of when to prefer this over the many sibling research/search tools, nor any exclusion. Usage is implied by the resource rather than argued.

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/openWorld/non-destructive, but the description adds substantial context beyond them: per-call credit range of 1–60, 'a failed call costs 0', and that handle re-reads are free. It also tells the agent to follow error.fix on failure and surface billing.display, which is behavior no annotation conveys.

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

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

Front-loaded with the core purpose and the sibling routing rule, then operational caveats. Slightly dense and telegraphic, and the per-platform op counts are the kind of enumeration that ages quickly, but every line carries a usable instruction.

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 still leaks the response shape the agent needs — page.cursor for pagination, request_id/handle for free re-reads, error.fix for remediation, billing.display for user-facing cost. Missing only an explicit statement of what a successful result contains.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: the 1–60 credit range that max_cost_credits guards against, the requirement to pass links whole as given, and how cursor/handle compose with an unchanged argument set. It stops short of explaining the shape of 'params', which is inherently op-specific.

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 ('Call one platform-specific capability by its op') and explicitly contrasts itself with two siblings, find and capabilities. The only friction is the unexplained reference to 'the six actions', which an agent must infer from the sibling list rather than read here.

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

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

Gives an explicit when-to-use condition ('what the six actions do not cover'), names the two routing alternatives (find to locate an op, capabilities to enumerate ops with parameters and cost), and adds operational rules for links, error handling, and billing disclosure. Nothing is left to inference.

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

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

Beyond the annotations, the description discloses important behavior: the result includes per-platform actions, operations, parameters, credits per call, page size, unsupported fields, and a working example call. It also mentions cost (free) and result size (the whole list is long), giving the agent practical context for invocation.

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 information is front-loaded and every major sentence adds useful context. The platform list is long but earns its place because it supplies valid parameter values not encoded in the schema; the only minor cost is readability.

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 still explains what the return value contains. Annotations already cover the safety profile, and the single parameter plus supported platform list is fully addressed, leaving no major gap for an agent calling this tool.

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

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

The schema already documents `platform`, but the description adds significant value by explaining why to use it (the whole list is long) and by listing the currently supported platform values. That compensates for the missing enum constraint in the schema and helps the agent pass valid values.

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

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

The description states a specific action and resource: 'List what can be called now', then enumerates exactly what the listing includes (actions, ops, parameters, credits, page size, limitations, and an example call). It is clearly a discovery/introspection tool, distinguishable from action-execution siblings such as `call`.

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 a clear usage condition: the full list is long, so pass `platform` to narrow it. It also notes the tool is free, which helps an agent decide to use it. It does not explicitly state when not to use it or name alternatives, keeping it just below 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?

Beyond the readOnly/openWorld annotations, it discloses that the work runs server-side, that a costly or background run replies with a price first, the exact credit cost per platform and scale, that `handle` re-reads an earlier result for free, and how to recover from errors. This is unusually rich behavioral context for a tool with real cost attached.

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

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

It is front-loaded with the purpose, followed by the billing table and the operating rules; every line carries information. The multi-line credit table is bulky but high-density, and it is arguably the most decision-relevant content for an agent weighing cost.

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 7-parameter, paid, possibly asynchronous tool with no output schema, this covers cost, confirmation, caching, and error handling well and sketches the return content. The notable omission is where it sits relative to sibling comment tools, and how paging or partial platform failures appear in the answer.

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

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

Schema coverage is already 100%, but the description adds semantics the schema cannot: the per-platform credit cost for each scale tier, 'pass links whole, as given' for `targets`, and how `confirm`/`max_cost_credits` intersect with the price-quote flow. That goes beyond restating the fields.

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

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

The description states a specific output: topics with their shares, questions, buying intent, and complaints with quoted comments, under a given set of posts. An agent can tell what it produces. It stops short of naming how it differs from the sibling tools `comments` or `brand_buzz`, so the boundary is left to inference.

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: you use it to learn what is being discussed under posts. Operational guidance is strong (pass links whole, run on error.fix, tell billing.display), but there are no exclusions or 'use X instead' routing against `comments`, `brand_buzz`, or `user_posts`.

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, covering the safety profile. The description adds valuable behavioral context beyond annotations: per-call credit costs, zero cost for failed calls, pagination charging, error recovery via error.fix, and billing.display notification.

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

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

The purpose is front-loaded, but the subsequent platform rules use cryptic notation (e.g., 'a|b: either one', numbers without units) that hinders parsing. It is compact but not optimally structured for quick comprehension.

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 9-parameter tool with no output schema and 67% schema coverage, the description adequately covers platform-specific invocation, pagination via limit, error recovery, and cost. It gives enough context to call the tool correctly, though the cryptic notation leaves some room for misinterpretation.

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 67% schema description coverage, the schema covers some parameters but not platform-specific requirements. The description adds significant meaning by mapping which platforms require id, id|url, or url, and which support reply_of, plus credit cost hints—information not present in 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: 'Read the comments under one piece of content. Read-only.' It is clear what the tool does, but it does not differentiate itself from the sibling tool comment_insights, leaving ambiguity about when to choose one over the other.

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 detailed invocation guidance—which platforms accept id, url, or reply_of, and how to use limit for pagination. However, it offers no explicit guidance on when to use this tool versus alternatives like comment_insights or search, so usage is only implied by the purpose.

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

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

Annotations already cover read-only, open-world, non-destructive behavior; the description adds meaningful context about remote execution, costly-run quoting, credit scaling, billing.display, and error.fix. It does not contradict annotations and gives useful operational expectations beyond the structured fields.

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

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

The purpose is front-loaded in the first sentence, and the remaining sentences cover cost, platform defaults, link handling, errors, and billing without obvious filler. The credit table is compact but cryptic, which slightly reduces readability.

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 six-parameter, open-world creator lookup with no output schema, the description covers what the result contains, cost behavior, default platforms, and error handling. It is nearly complete, though sibling differentiation and a clearer explanation of the credit table would improve 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 100%, so the baseline is 3, but the description adds real meaning through credit costs by scale and starting platform, default-platform behavior, and the instruction to pass links whole as given. The credit table is somewhat dense but adds parameter-relevant pricing context not found in 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 clearly establishes that this tool builds a cross-platform creator card for one person, including accounts, followers, posts, engagement, and identity-evidence strength. It is specific enough to understand the resource, but it does not explicitly distinguish itself from siblings such as find_creators, account, or user_profile.

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 use for a single creator across default platforms and includes operational notes about links, errors, and billing, but it never states when to use this instead of find_creators, account, or user_profile. There are no explicit alternatives or exclusion conditions.

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, openWorldHint, idempotentHint=false, and destructiveHint=false. The description adds valuable behavior beyond those: credit pricing per platform/call, zero cost for failed calls, extra charge for transcripts, and an instruction to surface billing.display. It does not cover auth or rate-limit behavior, but the billing/failure context is useful.

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

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

The description is compact and front-loads the core operation, but the platform matrix is dense and cryptic, with notations like 'x 1' and '12' that require interpretation. It packs useful information into few lines, but the structure is awkward and not 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 a seven-parameter, open-world content retrieval tool with no output schema, the description covers platform input rules, costs, and error handling well. However, it omits important schema-level parameters like handle and max_cost_credits and does not describe the return shape, leaving gaps for a complex tool.

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

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

Schema coverage is 71%, and the description meaningfully supplements it with platform-by-platform input modes, the valid type values for zhihu, and which platforms support include=transcript. It does not explain handle or max_cost_credits, but those are described in 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: get one piece of content by id or link, and notes it is read-only. It is distinguishable from broader search/list siblings by its id/link-based single-content lookup, though it does not explicitly name the sibling 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?

It gives substantial when/how guidance through the platform matrix: which platforms accept id versus url, when type=article|pin|question applies, and when include=transcript is available. It does not explicitly state when to prefer this over siblings like find/search/user_posts, but the platform-specific conditions are 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 declare readOnly/idempotent/non-destructive/closed-world, so the safety profile is covered. The description adds real behavioral context beyond that: the call is free, results are best-first, each result carries parameters and credits and a working call, docs links are appended for docs/code queries, and the not_offered failure mode is explained. Rate limits and result paging are not disclosed.

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

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

Purpose and result contents are front-loaded, which is good, but the prose is dense and run-on ('Find what can be called by what it does, in plain words, English or Chinese: ...'). The colon-chained clauses make it harder to scan than it needs to be, and the not_offered instruction is buried at the end.

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

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

There is no output schema, so the description rightly explains the return payload (actions, parameters, credits, a call, docs links) and the not_offered edge case. That covers what an agent needs in order to call it and interpret results. It is slightly short of complete because default/limit behavior and any result-size limits are left unmentioned.

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

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

Schema coverage is 100% and each of limit, query, and platform is documented in the schema. The description adds meaning the schema does not: that query accepts plain English or Chinese. limit and platform are left entirely to the schema, which already handles them.

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+resource: it finds callable capabilities/ops by what they do, returning matching actions with their parameters, credits per call, and a working call. That is concrete and distinct from sibling tools like call or account. It never names a sibling it is not (e.g. capabilities, search), so differentiation is implied 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?

Usage context is implied ('Find what can be called by what it does') plus guidance on a downstream situation: when not_offered appears, tell the user and do not pass off the closest calls as what was asked. There is no explicit when-to-use vs. the siblings (capabilities, search, call is right there in the list).

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

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

Annotations only declare the safety profile (readOnly, openWorld, non-idempotent, non-destructive); the description goes well beyond by disclosing server-side execution, that costly or long runs quote a price before running, and a full per-platform, per-scale credit cost table. The error.fix and billing.display instructions also give concrete operational behavior the agent cannot infer from schema or 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?

Purpose is front-loaded in the first sentence, followed by cost, then error/billing instructions, so the agent hits the most important facts first. The credit table is dense and long, but its compact semicolon format keeps it scannable and every entry is actionable cost data.

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 return-value burden and does so at a summary level (size, recent posts, fit with reasons). It covers cost, confirmation flow, error handling, and re-read behavior. A slightly clearer statement of return shape or what a quoted plan contains would close the remaining gap for a 9-parameter, costly, non-idempotent tool.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning beyond it: concrete credit figures per platform and scale tier, and the free re-read behavior of handle. The scale tiers (20/50/100) are already in the schema, so the marginal value is the cost mapping rather than parameter semantics per se.

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 first sentence names the verb and resource precisely and even summarizes the return payload: creator size, recent posts, and a fit score with reasons. It does not distinguish itself from siblings like creator_card, search, or research, which likely overlap, so the agent still can't rule alternatives out from the description alone.

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 query/platform framing and strengthened by the confirm semantics (plan-and-price vs. run) and the handle re-read path, which are genuinely useful decision cues. However, no sibling is named or excluded, so the agent gets no explicit guidance on when to pick this over creator_card or search.

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

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

Beyond the annotations, it discloses the credit-based billing model with actual per-platform/per-scale prices, the confirm flow, and the free handle re-read ('Nothing else is run.'). That is real behavioral context an agent cannot get from readOnlyHint/openWorldHint alone; it stops short of describing return shape or 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?

No filler sentences, but the telegraphic pricing shorthand ('kuaishou 2/12; wechat 24/12') and missing articles make it harder to parse than necessary. Information is front-loaded and every clause carries content, but readability suffers.

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 covers error handling, billing display, the free handle replay, and per-sub-tool inputs — enough to call it correctly. What a result actually looks like and how handle values are obtained are only lightly implied.

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

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

Schema coverage is already 100%, yet the description still adds substantial meaning: it enumerates each sub-tool's parameters (urls, max_cost_credits, confirm / query, platform, window, scale), lists valid platforms, and maps scale values to credit costs. That is well beyond the schema's generic 'That tool's inputs, by name.'

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 ('Run') and enumerates the two concrete sub-tools (batch_stats, viral_finder) with their inputs, so an agent knows exactly what this dispatcher exposes. It does not, however, differentiate the tool from similar-sounding siblings such as search, trending, or brand_buzz.

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 operational guidance — costly runs quote a price first, pass links whole, follow error.fix, surface billing.display — but never says when to pick this over research-adjacent siblings like search, trending, or brand_buzz. The when-to-use signal is implied by the sub-tool list rather than stated.

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

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

Annotations already declare read-only, open-world, non-destructive behavior, and the description adds significant context: per-call credit costs, failed calls costing 0, one call per page, max-cost refusal, and billing.display instructions. This is strong behavioral disclosure 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?

The description is information-dense but fragmentary and hard to parse, especially the platform/cost lists and terse phrases like "Each line: what to pass." The purpose is front-loaded, but structure and clarity are weak.

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 10-parameter search tool, it covers platform support, costs, pagination, and error handling well. It omits return-value/pagination response details and references a nonexistent limit parameter, leaving a notable 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?

With 90% schema coverage, the baseline is supplemented by useful platform-specific applicability for type, sort, since/until, and cost distinctions. However, it references limit=100 and capabilities, neither of which appears in the input schema, creating ambiguity.

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 "Search a platform for content" and "Read-only," giving a specific verb, resource, and scope. It does not name or distinguish itself from sibling tools such as find, research, or detail, so it falls short of a 5.

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

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

Provides extensive operational guidance: which platforms support query/type/sort/since/until, pagination behavior, billing, and error.fix handling. It stops short of explicitly saying when to use this tool instead of sibling discovery/search 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 establish read-only, open-world, non-destructive behavior, but the description adds substantial operational context: 2 credits per call unless numbered, one call per listed platform, failed calls cost 0, pagination is charged per page, max_cost_credits refusals are free, and handle rereads are free. It also tells the agent to follow error.fix and tell the user billing.display, which is valuable behavioral guidance 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?

The purpose is front-loaded and the description is short, but the telegraphic formatting and cryptic shorthand make it harder to parse than necessary. Sentences like 'Each line: what to pass, then platforms at 2 credits a call unless numbered' are dense and unclear.

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 tool with no output schema, the description covers cost rules, platform combinations, pagination, and error handling. It does not explain the shape or meaning of returned trending items, and the board-to-platform mapping remains unclear, leaving meaningful gaps for correct use.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning by mapping platforms to required parameters and explaining limit and handle behavior. The shorthand 'x 6' and 'xiaohongshu 12' is ambiguous, but overall it adds useful semantics 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: 'Read a platform's trending list.' It is clear enough to distinguish from generic search tools, but it does not explicitly contrast itself with siblings such as search, brand_buzz, or watch_news.

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 useful platform-specific parameter guidance, such as which platforms need no parameter and which accept type=videos or type=trends. However, it never states when to choose this tool over alternatives or when not to use it, so usage is only implied.

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, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds materially beyond that: 2 credits per call, failed calls cost 0, one call per page so limit=100 means multiple calls, and error handling via error.fix plus telling the user billing.display. That is genuine behavioral context an agent cannot get from 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 platform matrix is useful but dominates the description and is written in compressed fragments ('Each line: what to pass (a|b: either one), then platforms at 2 credits a call unless numbered') that require parsing effort. The core action and the cost/pagination facts are buried rather than 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 10-parameter, no-output-schema tool it covers identifiers, cost, pagination, and error recovery, which is more than most. It does not describe what a result contains (no output schema to lean on) and references a limit parameter that the schema does not define, leaving the agent's contract incomplete.

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

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

With 70% schema coverage, the description adds real meaning: which of id/username/url to supply per platform, and 'type=answer|pin: zhihu'. Against that, it instructs 'Pass limit=100' but no limit property exists in the schema, and 'More parameters: capabilities' ambiguously references what is actually a sibling tool. Those are likely to produce invalid calls.

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 gives a specific verb and resource: 'List what one account has published,' which tells an agent this is a per-account post listing rather than a search. However, it never contrasts with siblings like user_profile, detail, or search, so the boundary is inferred rather than stated.

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

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

The bulk of the text is an identifier matrix (id vs id|url vs username per platform), which is real invocation guidance. There is no when-to-use / when-not-to-use framing and no pointer to an alternative sibling when this tool is wrong.

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

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

Goes well beyond the readOnly/destructive annotations: states cost per platform (2 credits a call unless numbered), that failed calls cost 0, that max_cost_credits causes a free refusal, and directs error handling to error.fix and billing disclosure to billing.display. The handle parameter's free re-read behavior is also spelled out.

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 lead sentence and the find_creators pointer are well front-loaded, but the per-platform block is compressed into near-cryptic shorthand whose notation (numbers, pipes, 'unless numbered') costs the reader extra parsing. The content earns its place; the formatting does not.

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 6-parameter, no-output-schema tool, the description covers returned fields, per-platform input requirements, cost behavior, error recovery, and an alternative tool. The residual gap is the ambiguous cost notation rather than missing capability information.

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 coverage, the description does the heavy lifting by mapping each platform to the accepted identifier keys, which the schema alone does not convey. It loses a point because the notation is telegraphic ('a|b: either one', 'unless numbered') and the meaning of the trailing '12'/'1' markers must be inferred from the credits sentence.

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 — 'Get one account's public profile' — and enumerates the returned fields (name, bio, verification, follower counts). This clearly separates it from siblings like user_posts, creator_card, and account_watch.

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

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

Gives an explicit routing table of which parameter each platform requires ('Give id: bilibili...', 'Give id|username: tiktok, x, youtube'), plus an explicit alternative for bulk work: 'Many creators? find_creators sizes them up in one run.' The agent knows when to call this and when not to.

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 flag destructiveHint=true and readOnlyHint=false, so the description doesn't need to re-declare that. It adds real context beyond the annotations: every run is billed as the underlying call, a free account can hold only one watch, and failures should be handled via error.fix. It does not spell out what delete or revoke_feed actually destroys (does deleting a watch remove its feed history?), which is the main behavioral gap for a destructive tool.

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

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

Purpose is front-loaded and every sentence carries new information: workflow, action routing, billing, quota, error path. The first sentence is a 45-word chain of delivery targets and the 'list shows each watch's feed URL; pause, resume, delete...' line packs five actions into one clause, which costs readability. Dense but essentially fluff-free.

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, nested-input, destructive tool with no output schema, the description covers the two-phase commit, quota, billing, and error recovery, which is most of what an agent needs. It leaves out what a watch looks like once created (fields returned by list) and what happens to an existing watch when a new preview is made, gaps that matter given destructiveHint=true.

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

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

Schema coverage is 90%, so the baseline is 3, and the description earns above that by binding parameters to workflow steps (preview takes run/inputs/every/time/timezone/name/delivery; confirm takes token; id-taking actions are grouped). The note that inputs must be 'as that tool takes them' is useful framing for the nested object. It doesn't clarify what preview.display contains or how token lifetime works.

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 states a concrete verb+resource (a saved search/action/tool run repeated daily or weekly, delivering only new items) and enumerates delivery channels, which is far more than a restatement of the name 'watch'. It is not differentiated from the sibling watch_news or account_watch, which sound closely related, and the phrase 'delivering ... and watch_news' is ambiguous about whether watch_news is a channel or a separate 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 explicit operating procedure: call action=preview first, show the user preview.display, and only then call action=confirm with the token. It also routes the remaining actions (list, pause, resume, delete, rotate_feed, revoke_feed) to the id parameter, so an agent knows which action to pick. It never says when a user should prefer this over watch_news or account_watch, so the alternative-selection layer is missing.

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

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

Goes beyond the annotations by disclosing cost ('Free') and, critically, that reading consumes the items ('what is shown is not shown again') — which explains the otherwise puzzling idempotentHint=false on a readOnly tool. It does not cover error behavior or what happens when the queue is empty.

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 compact sentences, front-loaded with the resource and scope before the usage hint and the side-effect caveat. Nothing is padded or repeated.

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 a single optional parameter, no output schema and annotations covering safety, the description still supplies the ordering, returned fields, cost and the consume-on-read side effect. An agent has everything needed to call 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?

Schema coverage is 100% and the only parameter is already documented as 'Only this watch.' The description's 'Pass id for one watch' restates rather than extends that, so the baseline 3 applies.

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

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

States a specific verb and resource ('what the user's watches found'), plus the scope ('not shown yet'), ordering ('newest first') and payload ('each watch, its time and status'). This clearly separates it from siblings like watch and account_watch, which manage watches rather than return findings.

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?

'Use it when the user asks what is new' gives a concrete triggering condition and the 'Pass id for one watch' clause signals the narrow variant. No explicit exclusions or named alternatives, 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.