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

Annotations already declare readOnlyHint and openWorldHint, and the description adds substantial behavioral context: cost (3 credits live, 0 cache hit), a clear public-data boundary (no bios, contact details, login-walled data), pagination via nextCursor, and platform-specific field naming. No contradiction with annotations.

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

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

The description is compact and front-loaded with the core purpose, followed by distinct, valuable details: cursor, field naming, cost, public scope, and read-only nature. Every sentence earns its place with no filler or redundancy.

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

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

For a simple paginated read operation, the description covers response shape, pagination, cost, access limits, and safety. However, since there is no output schema, it leaves some ambiguity about exactly what fields an item in the page contains; the statement 'Fields use this platform's own names' hints but does not enumerate them.

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. The description adds meaningful meaning by linking the cache parameter to credit costs and the cursor parameter to nextCursor. It does not elaborate on limit or URL formatting beyond the schema, but it does supplement the schema rather than merely repeat it.

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

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

The description clearly identifies the resource ('recent public posts for an Instagram account') and the operation ('Returns a page of items plus nextCursor'). It conveys pagination and public scope, which helps distinguish it from stats/profile siblings, but it does not explicitly name sibling alternatives, so it stops short of full differentiation.

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

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

There is no guidance on when to use this tool versus alternatives like instagram_stats or instagram_profile. The phrase 'recent public posts' implies its use case, but no explicit conditions, exclusions, or sibling routing are provided.

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

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

Annotations already give readOnlyHint=true and openWorldHint=true, so no contradiction there. The description adds real context beyond the annotations: cache behavior (0 credits on cache hit vs 2 on live read), scope exclusions (no bios, contact details, login-walled data), and the fact that it returns one object. That's meaningful over what annotations provide, but it doesn't describe pagination or error behavior, so I'm not giving 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 description is compact and front-loaded: it starts with the main payload and scope, then cost, then exclusions. Each sentence adds distinct information. Minor deduction because the exclusions and read-only note could be merged slightly, but it's still concise and well-structured.

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

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

There's no output schema, so the description partially covers the return shape by saying 'returns one object' and listing fields (follower/post counts). Given the tool is simple (2 params) and annotations are strong, this feels reasonably complete. It doesn't state obvious edge cases like invalid/private usernames, but for a public-data read API it's enough to call 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%, so the schema already documents both parameters clearly. The description reinforces them by tying the cost to a live read vs cache hit — that adds semantic understanding to the cache parameter beyond the schema's description. Similarly, saying 'public URL' aligns with the url param example. That's useful without duplicating the schema verbatim.

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 pairing ('Follower and post counts for a public Instagram account'), distinct from sibling stats tools. It also explicitly scopes out private data, which shrinks ambiguity about which endpoint this is.

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 context: public accounts only, and credits/cost behavior distinguishing live read vs cache hit. It doesn't name alternatives like instagram_stats or instagram_posts, so the agent isn't told exactly when to pick this over a sibling, but the platform and resource are clear enough to infer.

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 and openWorldHint, and the description adds valuable behavior: credit cost on live reads, free cache hits, return shape ('one object'), platform-specific field naming, and explicit exclusion of private or profile data. No contradiction.

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 short, front-loaded sentences with no wasted words. Each sentence adds a distinct piece of information: scope, return shape, cost/cache behavior, and public-data restrictions.

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 two-parameter read-only tool, the description covers purpose, parameter behavior, return shape, cost/cache semantics, and data boundaries. Nothing essential for invoking it correctly is missing.

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

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

Schema coverage is 100% and both parameters (url and cache) already have explanatory descriptions. The tool description adds no parameter-specific meaning beyond the schema, so the baseline of 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 clearly that it returns likes, comments, and views for a public Instagram post or reel as a single object. This distinguishes it from sibling profile/posts/stats tools by resource type and data scope.

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

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

Provides clear context: use it for public posts/reels, not for bios, contact details, or login-walled data, and it explains the cache/live-cost tradeoff. It does not explicitly name sibling alternatives, but the boundary conditions make the appropriate use reasonably 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?

Beyond the readOnlyHint annotation, the description adds concrete behavioral details: 2 credits on live reads, 0 on cache hits, public-data-only scope, pagination via nextCursor, and platform-specific field naming. It aligns with annotations rather than contradicting them.

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

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

The description is compact and front-loaded, with each sentence serving a purpose: purpose, return shape, cost, data scope, and read-only status. No filler or repetition beyond a minor redundant 'Read-only' tag.

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?

Without an output schema, the description provides a reasonable shape: a page of items plus nextCursor. It explains the data scope and cost, though it does not enumerate item fields; this is acceptable given the schema covers all input parameters.

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 input schema already provides 100% coverage with descriptions for url, cache, limit, and cursor. The description adds little parameter-level detail beyond reinforcing the cursor/nextCursor pagination relationship and the platform-specific field names.

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

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

States a specific verb and resource: 'Returns a page of recent public videos for a TikTok account.' It also distinguishes itself from likely siblings like tiktok_stats and tiktok_profile by focusing on paginated video items rather than stats or profile details.

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

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

Clear context is provided: use this for recent public TikTok videos with cursor pagination. It also implicitly warns against use when bios, contact details, or login-walled data are needed, and notes the cost difference between cache hits and live reads.

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

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

Annotations already mark the operation as read-only, and the description echoes that while adding useful behavioral details: cost differences between live reads and cache hits, the single-object return shape, and the fact that field names use TikTok's own terminology. No contradiction with annotations exists.

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

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

The description is brief, front-loaded with the core purpose, and every sentence adds useful information: scope, return shape, field naming, cost, and data limitations. There is no fluff or unnecessary repetition.

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

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

For a read-only, two-parameter tool with fully documented schema and helpful annotations, the description provides enough context to call it correctly: what data comes back, what public scope means, how caching affects cost, and what is deliberately excluded. No critical invocation information is missing.

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

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

The schema already covers both parameters fully: the url format/example and the cache default/behavior. The description adds no parameter-specific semantics beyond the cost implication of a live read, which is already described in the schema. With 100% schema coverage, baseline 3 is appropriate.

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

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

The description clearly states what the tool returns: follower, video, and heart counts for a public TikTok account, and it notes that the result is one object. It is unambiguous about the resource and scope, but it does not explicitly differentiate itself from sibling tools like tiktok_stats or instagram_profile, 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?

The description gives clear boundary conditions: public data only, no bios, no contact details, and no login-walled data. This tells an agent when not to use the tool, and the cache/cost note adds practical usage context, but it does not name alternative tools or explicit when-to-use-versus-other choices.

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 description goes well beyond the readOnlyHint and openWorldHint annotations by disclosing credit cost on live reads vs cache hits, the public-data boundary, and the platform-specific field naming convention. It also states read-only behavior explicitly. No contradiction with annotations exists.

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

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

The description is compact and front-loaded with the key metrics, then adds return shape, field naming, cost behavior, and access boundaries. Each clause earns its place, and the only minor redundancy is 'Read-only' duplicating the annotation, which is not enough to penalize.

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 only two simple parameters and no output schema, the description sufficiently covers what an agent needs: the input URL, cache/cost behavior, output shape ('one object'), the fields returned, and the public-data restriction. No critical call-time information is missing.

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

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

Schema description coverage is 100%, so url and cache are already well documented. The description reinforces the cache parameter by explaining the credit difference between live reads and cache hits, but it does not add substantial new parameter-level meaning beyond the schema's own examples and defaults.

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?

Description identifies the exact resource (a public TikTok video) and the specific metrics returned (views, likes, comments, shares, collects), then states 'Returns one object.' Sibling tools like tiktok_profile and tiktok_posts are clearly different in scope, so an agent can distinguish this tool without opening the schema.

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

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

The description gives useful context for when this tool applies: public TikTok video stats, with explicit limits ('Public data only: no bios, contact details or login-walled data'). However, it does not name sibling alternatives or state conditions for choosing this over tiktok_profile, tiktok_posts, or youtube_stats, so the usage guidance remains implied rather than explicit.

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 description adds cost behavior (1 credit live read, 0 on cache hit), a return-shape guarantee (one object), and a naming-convention caveat, going beyond the readOnlyHint/openWorldHint annotations. The read-only annotation is consistent, and there is no contradiction.

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?

Six short sentences, each adding information, with the core purpose front-loaded. Some slight redundancy exists between 'Public data only' and 'Read-only', but no sentence is wasted.

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

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

With no output schema, the description gives enough of the return contract by naming subscriber/video counts, one object, and platform-specific field names. It could list exact fields, but for a simple read-only query the current level is solid.

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?

Both parameters are fully described in the schema, so the baseline is 3. The description does not add parameter-specific meaning beyond naming 'cache hit' and a public URL, which the schema already covers.

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

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

The description opens with 'Subscriber and video counts for a public YouTube channel,' naming a specific output and resource. It also states the return shape ('Returns one object') and is distinguishable from sibling tools such as youtube_videos or youtube_transcript.

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

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

Usage is implied: use when you need a channel's subscriber and video counts. It does not explicitly compare itself with siblings or state when not to use alternate tools, though the 'public data only' sentence hints at some exclusions.

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

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

Annotations already mark it read-only, and the description adds meaningful behavior beyond that: live reads cost 1 credit while cache hits are free, returned fields use the platform's own names, and only public data is accessible. No contradiction with 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 compact, front-loads the main purpose, and keeps cost/data scope in short sentences. The final 'Read-only' is redundant with the readOnlyHint annotation, which keeps it from a perfect score.

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

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

For a simple two-parameter read-only tool, the description covers purpose, return shape, cost behavior, and data scope. There is no output schema, but the main return values are stated clearly enough for an agent to invoke and interpret results.

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%, with the url parameter explained by example and the cache parameter stating its default and cost behavior. The description adds no parameter-level meaning beyond the schema, so the baseline of 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 names a specific verb-resource pair: it returns view, like, and comment counts for a single public YouTube video or Short. It also signals granularity via 'Returns one object,' which distinguishes it from list- or channel-level siblings like youtube_channel and youtube_videos.

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

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

It clearly scopes use to public video/Short stats and explicitly excludes profile-like or non-public data, saying there are 'no bios, contact details or login-walled data.' It does not name an alternative tool for channel-level stats, so it stops short of the explicit routing that would merit a 5.

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

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

Beyond the readOnlyHint annotation, the description adds useful behavioral context: cost differences between live reads and cache hits, the single-object return shape, and the public-data-only scope. It does not over-promise on return size or completeness, though it omits edge cases like videos without transcripts.

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, front-loaded with the core purpose, and each sentence adds distinct value: output type, field naming behavior, cost, data scope, and read-only nature. There is 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?

Given no output schema, the description adequately conveys what the agent should expect: a single object representing the full transcript with timed segments. Combined with the complete parameter schema and annotations, this is enough for correct tool selection and invocation, though explicit field names are not provided.

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

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

Schema description coverage is 100% for both parameters, so the schema already documents semantics. The description does not elaborate on the parameters, but the baseline of 3 applies because no additional explanation is necessary for an agent to use them correctly.

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

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

The description clearly identifies the resource (full spoken transcript of a public YouTube video) and the output shape (one object with timed segments). This unambiguously distinguishes it from sibling tools like youtube_stats or youtube_videos.

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

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

The description makes clear the tool is for fetching spoken transcript content and notes it is limited to public data, which helps agents avoid using it for private or login-walled videos. It does not explicitly name alternatives, but the sibling set and resource clarity make the intended use obvious.

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 readOnlyHint annotation, the description discloses the cost model (2 credits live, 0 on cache hit), the public-data-only boundary, and the fact that fields use this platform's own names. It adds meaningful behavioral context without contradicting the annotations.

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

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

The description is compact and front-loaded with the core purpose and pagination behavior, then adds cost and scope details. There is slight redundancy between the first and second sentences, both mentioning a 'page' and 'cursor', so it is not perfectly tight.

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

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

For a paginated read-only tool with no output schema, the description gives enough to invoke it correctly: return shape (items plus nextCursor), cost/cache behavior, and public-data scope. It does not enumerate the item fields, but the note that fields use this platform's own names mitigates that gap.

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

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

The input schema already documents all four parameters with 100% coverage, so the description does not need to restate them. It does add useful pagination context by mentioning items plus nextCursor and platform-specific field naming, but it does not add new syntax-level meaning 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 uses a clear verb ('Returns') and resource ('a page of recent public videos for a YouTube channel'), and the cursor/pagination detail makes the tool's specific role obvious. It is easy to distinguish from the sibling stats, channel, transcript, and platform-specific tools because it is explicitly about public videos.

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

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

The description clearly frames the tool for public, read-only video data and explicitly excludes bios, contact details, and login-walled data, giving an agent a good sense of when it is appropriate. It does not name sibling alternatives such as youtube_transcript or youtube_stats, so the guidance is contextual rather than explicitly comparative.

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