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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses almost nothing beyond the transformation itself: no statement about output format, determinism, latency/cost, or the fact that api_key is optional-only-when-needed. For a generative tool with zero annotation coverage this is a significant gap.

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

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

A single well-formed sentence with the action verb front-loaded and the platform list at the end. No filler, though it is thin for the amount of behavior an annotation-free tool must explain.

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 four parameters, no output schema, and no annotations, the description is the only source of behavioral context and it covers essentially just purpose. It is minimally adequate for calling the tool but leaves output shape, platform constraints, and auth behavior unstated.

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

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

Schema description coverage is 100%, so the schema already documents topic, tone, platforms, and api_key; the description adds only a loose mapping of 'hook, script, or topic' to the topic parameter and implies which platforms are supported. Baseline 3 is appropriate when the schema carries the detail.

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

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

States a specific verb (transform) and inputs (a single hook, script, or topic) and names the concrete target platforms, so the resource and scope are unambiguous. It does not differentiate itself from siblings such as reeling_evaluate_content_jev or reeling_generate_video, so it stops 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 imperative 'Use ... to transform' implies the use case, but there is no explicit when-to-use vs. alternatives, no exclusions, and no mention of when the sibling evaluate/generate tools would be preferable. Usage is implied rather than guided.

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

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

No annotations are provided, and the description usefully discloses that no API key is required and what the tool returns: a safety_score, trigger explanations, sanitized copy, and a verification badge. However, it does not cover side effects, data retention, rate limits, or whether the original content is modified.

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

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

The description is two sentences, front-loads the public/no-key access context, then states the core operation and outputs. Every sentence contributes useful information without waste.

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

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

For a simple three-parameter public evaluation tool with full schema coverage, the description covers purpose, access requirements, and return values even though no output schema exists. It lacks sibling routing and deeper behavioral details, but is otherwise complete enough to invoke 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 all three parameters. The description mentions the title, body, and platforms, but adds no format, default, or enum information beyond what the schema provides.

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: it evaluates a draft title and post body against a spam/automod shield for listed platforms. This is clear, but it does not explicitly differentiate itself from sibling tools such as reeling_evaluate_content_jev.

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 terms 'Pre-Publish' and 'draft' clearly signal the usage context: checking content before publication. It also notes 'No API key required,' giving access context, but it does not state exclusions or name alternative tools for related evaluations.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the shape of the generated artifact (5-second cuts, timecodes, camera movements, foley cues), but says nothing about whether the storyboard is persisted, whether an API key is required despite the optional api_key parameter, rate limits, or cost. The output-format detail is real value, but key operational traits are missing.

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 dense sentence with the core action and the produced artifact front-loaded, and no filler. Every clause (duration range, cut length, output fields) earns its place.

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

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

There is no output schema, but the description effectively substitutes by enumerating what the storyboard contains (timecodes, scene titles, camera movements, audio/foley cues), so an agent knows what comes back. It is still thin on auth/persistence behavior and on distinguishing itself from sibling generation tools, which keeps it from a 5.

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

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

Schema coverage is 100%, so every parameter is already documented in the schema and the baseline is 3. The description corroborates the duration range ('from 30 seconds up to 5 minutes') matching duration_seconds, but adds no syntax or meaning beyond what the schema states.

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 ('Generate') and resource ('AI multi-scene storyboard') and specifies output granularity (sequential 5-second cinematic cuts with timecodes, scene titles, camera movements, audio/foley cues). It is clearly distinct from reeling_stitch_storyboard and reeling_generate_video, but it never names or contrasts those siblings explicitly, so it stops short of a 5.

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

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

There is no statement of when to use this tool versus reeling_generate_video or reeling_stitch_storyboard, and no prerequisites or exclusions. The only usage hint is the implicit 30-second to 5-minute duration scope, which is context but not guidance.

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

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

No annotations exist, so the description carries the full burden. It usefully discloses concrete rate limits (max 3 answers/day, 3 top-level posts/week) that an agent could not learn elsewhere, but it never states the operation is read-only, whether api_key is needed for full results, or anything about the shape of the returned threads/questions.

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, and the discovery scope leads. It does somewhat conflate two functions (searching and checking quota counters) in one line, which costs a small amount of crispness.

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

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

With no annotations, no output schema, and four optional parameters, the description covers the main search and the quota limits but leaves open return format, whether quotas gate the discovery call, and what happens with missing api_key or project_id. Adequate but with clear gaps for a multi-parameter read tool.

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

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

Schema description coverage is 100%, so the schema already documents keywords, subreddits, api_key, and project_id. The description names keywords and subreddits consistently with the schema but adds no syntax, defaults, or interactions beyond 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?

States a specific verb (discover) and concrete resources (daily Reddit threads and Quora questions) scoped by keywords/subreddits, which distinguishes it from siblings like reeling_draft_community_answer or reeling_reply_to_comment. The secondary mention of Cadence Guard counters slightly muddies the single-function read, but the core purpose is unmistakable.

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?

'Daily' implies a recurring discovery workflow and the subreddit/keyword scoping hints at when to use it, but there is no explicit when-not-to-use or named alternative. The natural 'discover first, then draft' relationship to reeling_draft_community_answer is left for the agent 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?

With no annotations, the description carries the full burden. The word 'Draft' usefully signals this does not publish, and 'verified by Reeling's Spam Shield' discloses a validation step, but it says nothing about whether the draft is persisted, what permission/auth is needed (api_key is described as optional in the schema only), 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?

A single sentence with the action, target resource, and quality constraint front-loaded. Nothing is wasted or buried.

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 generation tool with no output schema and no annotations, the description is thin. It does not say whether the returned draft is saved server-side, whether it can be passed straight to reeling_publish_post, or how strictly the Spam Shield changes the output.

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 applies. The description only echoes the platform enum (Reddit/Quora) and adds no meaning about subreddit, project_context, question_snippet, or the optional api_key beyond what the schema already documents.

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

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

Specific verb plus resource: 'Draft a ... answer for a Reddit thread or Quora question.' That is clearly different from reeling_check_spam_score or reeling_discover_community_questions, but the description never names those siblings or explicitly places this tool after discovery, so differentiation is implied rather than stated.

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

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

Usage is only implied: an agent can infer this is the drafting step that follows question discovery, and the Spam Shield mention implies the output is pre-validated before publishing. There is no explicit when-to-use, when-not-to-use, or named alternative such as reeling_check_spam_score or reeling_publish_post.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose that results come from Zod-validated evaluation and that caching exists (force_fresh toggles live vs cached), plus what is returned (prescriptions). However it omits auth/permission requirements, rate limits, and whether the operation is read-only, leaving meaningful gaps.

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?

Single sentence, front-loaded with the action, which is good. But it is dense and jargon-heavy, packing the acronym expansion and five evaluation dimensions into one clause, which costs 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?

No output schema exists, and the description usefully previews the return (actionable prescriptions). However, it never explains how the target post is identified — there is no post-ID parameter, only api_key and force_fresh — leaving a significant ambiguity for a tool that claims to evaluate a specific post's metrics.

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 both api_key and force_fresh are already documented in the schema. The description adds no syntax or semantics beyond that. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb (run a JEV diagnostic) on a specific resource (published post metrics) and enumerates the dimensions evaluated, so an agent can distinguish it from generic siblings like get_analytics or sync_metrics. The 'JEV' acronym is jargon but is expanded inline, keeping the purpose legible.

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 when-to-use, when-not-to-use, or prerequisite guidance is given. It never clarifies whether this should follow sync_metrics or complement get_analytics, nor what state a post must be in. Usage must be inferred from 'published post metrics'.

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

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

With no annotations the description carries the full burden. It does disclose useful side effects: automatic save to Cloudflare R2 and a returned public media URL, plus a speed claim ("in seconds"). It omits whether generation is synchronous or a long-running job, any cost/quota or rate-limit behavior, and auth expectations despite an optional api_key param.

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

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

Two tight sentences with no filler, and the core action is front-loaded. The trailing "ready for publishing to..." clause adds intent but is slightly promotional rather than operational.

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?

It covers purpose, the storage side effect, and the return value, which is important since there is no output schema. It stops just short of the operational details (async vs sync, latency, cost) an agent generating media 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%, so the schema already documents prompt, image_url, aspect_ratio, and the two keys. The description adds no parameter-level detail (e.g., interaction between prompt and image_url, or default behavior), 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 ("Generate short-form video clips") and even names the underlying models (MiniMax H3 Max, Video-01). It doesn't, however, distinguish itself from the storyboard siblings (create_storyboard, stitch_storyboard), which is the nearest overlapping capability set.

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 when-to-use or when-not-to-use guidance and never names an alternative. The only implied context is "ready for publishing to YouTube, TikTok, Instagram," which hints at downstream intent but does not help an agent decide between this and create_storyboard/stitch_storyboard.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read, but omits whether retrieval triggers a sync, whether the api_key is required for authorization, rate limits, or default behavior when dates are omitted.

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, front-loaded with the verb and resource, with no padding. The metric list earns its place because no output schema exists to describe the return fields.

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

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

Enumerating return fields compensates for the absent output schema, and safety is not a concern for a read tool. However, with zero required parameters the description never explains default date behavior or auth expectations, leaving 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?

Schema description coverage is 100%, with all three parameters (api_key, start_date, end_date) documented in-schema, so the baseline is 3. The description adds no extra parameter meaning such as date format requirements, defaults, or the effect of omitting a range.

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 (Retrieve) and resource (aggregated performance analytics) and enumerates the returned metrics, so the tool's function is unambiguous. It does not differentiate itself from siblings such as reeling_sync_metrics or reeling_get_post_status, which an agent could plausibly confuse it with.

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. Nothing says whether metrics must first be refreshed via reeling_sync_metrics, or when to prefer this aggregate view over reeling_get_post_status for individual 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?

With no annotations, the description carries the full behavioral burden. "Retrieve" implies a read-only, non-destructive operation and the examples usefully sketch the return shape (board ID, name, privacy). However, it omits auth requirements, rate limits, and whether options are paginated — real gaps for a zero-annotation 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?

A single tight sentence, front-loading the verb and resource with the examples as supporting detail. Nothing is wasted, though it is minimal enough that a little more context could fit without bloat.

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 one-required-parameter read tool with no output schema, the description partially compensates by naming returned fields. But it gives no usage context or auth notes, so an agent still lacks the framing needed to know when this call belongs in a workflow.

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

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

Schema description coverage is 100%, and the schema already explains channel_id as a UUID sourced from reeling_list_channels and marks api_key optional. The description adds 'connected channel' framing but no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

The description pairs a specific verb ("Retrieve") with a specific resource ("publishing options for a connected channel") and disambiguates with concrete examples (Pinterest boards, TikTok creator configs). An agent can distinguish it from siblings like reeling_list_channels or reeling_publish_post. It stops short of explicitly naming a sibling it contrasts with, so it is not 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, no prerequisites, and no alternatives mentioned. The agent must infer that this is a discovery call preceding publishing. The examples hint at purpose but don't route the agent between 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?

With no annotations, the description carries the full behavioral burden. It implies a read ("Fetch") and names the aggregated platforms, but says nothing about pagination, result ordering, volume, rate limits, or authentication needs despite the optional api_key parameter.

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 identifies the resource and its scope with no filler. Nothing is wasted and the key information leads.

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-optional-parameter read tool with no output schema and no annotations, the description covers what the tool is but not what the response contains or how large it may be. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so both parameters are already documented, including the platform enum values. The description's platform list mirrors the schema rather than adding new semantics, so the 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?

States a specific verb (Fetch) and resource (unified social inbox) and enumerates the covered platforms, so the agent knows exactly what comes back. It does not explicitly contrast itself with siblings such as reeling_reply_to_comment or reeling_get_analytics, 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 statement of when to call this versus alternatives like reeling_reply_to_comment or reeling_get_analytics, and no prerequisites or ordering guidance. Usage is only implied by the tool's name and 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?

With no annotations, the description carries the full burden and does disclose key traits: it is public, requires no API key, and returns static capability/pricing metadata rather than user data. It does not explicitly confirm read-only/no-side-effects or note caching or rate limits, but the 'Returns' framing and no-auth note cover the main concerns.

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 tightly packed sentence with the access qualifier and no-API-key note front-loaded, so the agent learns the most decision-relevant fact first. The enumerated payload list is dense but every element earns its place.

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

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

With no output schema and no annotations, the description compensates by listing exactly what the response contains (platforms, auth methods, limits, pricing). Adequate for a zero-required-parameter reference tool; only the shape of the returned records is left unspecified.

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

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

The single optional 'platform' filter is fully documented in the schema at 100% coverage, including example keys, so the schema does the work. The description never mentions filtering, so it adds no meaning beyond the schema — 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 (Returns) and a precise resource (Reeling's 15 supported platforms) and enumerates the payload (auth methods, limits, pricing tiers), which no sibling tool provides. An agent can immediately tell this is the reference/metadata tool rather than an action tool like reeling_publish_post or reeling_list_channels.

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?

'PUBLIC DISCOVERY TOOL (No API key required)' implies this is a lookup to consult before acting, but the description never says when to call it versus related siblings such as reeling_get_channel_options or reeling_list_channels. Usage is inferable rather than stated, with no explicit 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?

With no annotations, the description carries the full behavioral burden; it does convey that the result is aggregated across all targeted networks (useful scope behavior) and that the operation is a read. It says nothing about auth requirements, whether status is cached/eventually consistent, or how partial failures per network are represented.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though it is terse enough that it spends no words on routing or return-shape context.

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 two-parameter read tool with no output schema and no annotations, the description is only marginally complete: it does not describe the shape of the returned per-network statuses, which an agent would need given the absence of an 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 description coverage is 100% — post_id and api_key are both documented in the schema — so the baseline of 3 applies. The description adds no format, syntax, or uniqueness detail beyond what the schema already states.

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 (retrieve) and resource (delivery and publishing status for a post), with a clear scope qualifier ('across all targeted social networks'). It is easy to distinguish from siblings like reeling_get_analytics or reeling_sync_metrics, though the description never explicitly contrasts itself with them.

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 statement of when to use this versus alternatives such as reeling_get_analytics or reeling_sync_metrics, and no prerequisites or exclusions. Usage is only implied by the word 'status'.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the return payload (account details, usernames, statuses), which is useful, but says nothing about read-only semantics, authentication requirements, or pagination/result limits for potentially long channel lists.

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 wasted clauses; the platform enumeration is arguably long but does add useful scope information. Nothing extraneous.

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 listing tool with no output schema, the description covers the essentials by naming the returned fields. Missing only pagination/ordering behavior and auth expectations, which are minor for 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?

Schema coverage is 100%, so both optional parameters are already documented in the schema. The description adds no detail about the project_id filter or api_key beyond what the schema states, 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 a specific verb ('List') and resource ('connected social media channels') and enumerates the platforms covered, so the agent knows exactly what comes back. It does not explicitly contrast itself with siblings like reeling_list_projects or reeling_get_channel_options, but the scope is unambiguous.

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

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

There is no guidance on when to call this versus reeling_get_channel_options, nor any mention of prerequisites or the significance of the optional api_key/project_id. Usage must be inferred from the name alone.

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

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

With no annotations, the description carries the full behavioral burden. It implies a read-only listing and notes account scoping, but says nothing about authentication requirements, pagination, rate limits, or the shape of results. For a tool with zero annotation coverage, this is a significant gap.

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

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

A single, front-loaded sentence with no wasted words; the verb and resource lead immediately. The only slight redundancy is the "projects / workspaces" pairing, which is minor.

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 listing tool with one optional parameter and no output schema, the description is minimally adequate. However, it omits any mention of pagination, result size, or ordering, which an agent would benefit from knowing when enumerating projects.

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

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

Schema description coverage is 100% and the single api_key parameter is fully documented in the schema (optional, environment fallback). The description adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

The description states a specific verb ("List") and resource ("projects / workspaces"), which is distinguishable from siblings that operate on channels, posts, or analytics. It clearly conveys scope ("available in your reeling.app account"), though it does not explicitly name a sibling it differs from, so it falls short of a 5.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as reeling_list_channels. Usage is only implied by the verb "List." No exclusions or routing hints 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?

With no annotations at all, the description carries full burden for a destructive, multi-platform write operation, yet it discloses nothing about irreversibility, per-platform auth requirements, partial-failure behavior when one platform rejects the post, or rate limits. The rate-limit information that does exist (3/day, 3/week) lives only in the mode parameter description, not 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 front-loaded sentence with the verb in the first word and no filler. The long parenthetical platform list is somewhat bulky but does helpfully map human platform names to the platform keys used by the params.

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 15-parameter, 13-platform publishing mutation with no annotations and no output schema, one sentence is far too thin. Nothing tells the agent what a successful or partially successful publish returns, how to verify results, or what to do when a platform key is invalid or a required per-platform field (e.g. video_url vs content) 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 every one of the 15 parameters is already documented in the schema, including the mode enum, scheduling format, and Pinterest board fallback. The description adds no parameter-level meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb ('publish or schedule') plus the resource (short-form videos, articles, posts) and enumerates the target platforms, so the action is unambiguous. It does not distinguish itself from siblings such as reeling_generate_video or reeling_draft_community_answer, leaving the agent to infer where drafting/generation ends and publishing begins.

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

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

There is no when-to-use guidance, no prerequisites (e.g. connected channels via reeling_list_channels), and no named alternatives such as reeling_check_spam_score before publishing or reeling_get_post_status after. The agent must infer the entire workflow context from the tool name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not state that the reply is published immediately (a mutation), what auth or permissions the api_key implies, whether replies are reversible/deletable, or any rate limits or platform-specific failure modes.

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

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

One sentence, front-loaded with the core action and resource, with the platform scope appended. No padding or redundant restatement.

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

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

This is a write/mutation tool with no annotations and no output schema, and it carries a nested, platform-specific reply_context parameter (e.g. Bluesky root URI/CID). The description says nothing about platform-specific requirements, permissions, or what a successful reply returns, so it is thin for the actual complexity.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters; the description only repeats the platform list. It adds no meaning for comment_id, reply_text, or the nested platform-specific reply_context object.

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

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

Names a specific verb and resource (send a direct reply to a comment) and enumerates the supported platforms. It is clearly distinguishable from siblings like reeling_publish_post or reeling_get_inbox, though it does not explicitly contrast itself with them.

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 action and platform list, but the description offers no explicit when-to-use, when-not-to-use, or alternative-tool guidance (e.g. when to reply versus publish a new post). Nothing is misleading, but nothing routes the agent either.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose meaningful traits: external dependencies (fal.ai MiniMax H3, FFmpeg) and a persistent side effect (upload to Cloudflare R2, i.e., external storage mutation). However it omits cost/credit consumption for scene rendering, expected latency for a multi-scene render, partial-failure behavior, and what happens to scenes that already carry a videoUrl.

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, front-loaded on the core action ('Render each scene...'), with zero filler and every clause contributing a distinct stage of the pipeline. Nothing redundant or padded.

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

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

There is no output schema, so the description should ideally indicate the return value; it only implies the final artifact's storage destination (R2) without saying what is handed back (e.g., a URL). Combined with the absence of annotations and no mention of cost or handling of partial renders, it is adequate but leaves real gaps for a multi-step, paid, mutating pipeline.

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 75%, so the baseline of 3 applies. The description adds no parameter-level meaning: it does not explain the api_key vs fal_api_key (BYOK) split, how aspect_ratio affects output, or whether a scene's pre-supplied videoUrl means it is reused rather than re-rendered — a semantically important ambiguity left unresolved.

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 concrete multi-stage verb pipeline: render each scene via fal.ai MiniMax H3, stitch into one continuous MP4 with FFmpeg, upload to Cloudflare R2. That is far more specific than a tautology and inherently separable from reeling_generate_video or reeling_create_storyboard, but it never names or routes against those siblings explicitly, so differentiation 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: the required 'scenes' array signals this runs on an existing storyboard, so the ordering after reeling_create_storyboard is inferable. There is no explicit when-to-use statement, no exclusions, and no guidance on choosing this over reeling_generate_video.

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

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

With no annotations, the description carries the full burden. It discloses that the sync hits live external APIs, hinting at network behavior, but says nothing about the required API key, rate limits, latency, idempotency, or whether metrics are written back to storage versus merely fetched — all material for a sync trigger.

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 tight sentence with the triggering action front-loaded and the platform list as useful scope. It is well-sized, though the parenthetical platform list is somewhat expendable.

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

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

For a low-complexity tool with 2 optional flat parameters and no nested objects, the description is minimally adequate. However, with no annotations and no output schema, it should state whether the sync persists results, how long it takes, and when it should be preferred over reeling_get_analytics.

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 api_key ('Optional Reeling API key') and post_id ('Optional post UUID') are already documented in the schema. The description adds no meaning beyond that and never mentions either parameter, 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 ('trigger') and resource ('on-demand real-time metric sync') and enumerates the platforms it operates against, so the action is clear. It fails to differentiate from the sibling reeling_get_analytics or reeling_get_post_status, leaving the read-vs-refresh boundary for the agent to guess.

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?

'On-demand' and 'live APIs' imply this is a user-triggered refresh rather than a passive cached read, which is weak implied guidance. There is no explicit when-to-use statement, no exclusion of the analytics/status siblings, and no note that post_id narrows the sync to one post.

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