ReelFarm MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.1
Disambiguation5/5
Every tool has a clearly distinct purpose, and even near-overlapping pairs like generate_slideshow vs. create_slideshow or publish_video_via_automation vs. publish_to_tiktok are explicitly differentiated by AI/manual control and automation vs. direct publication. The descriptions eliminate ambiguity.
Naming Consistency4/5
The naming is overwhelmingly consistent: verb_noun snake_case (list_automations, get_video, publish_to_tiktok). The only deviation is slideshow_status, which is a noun_noun format, but all other tools follow the pattern, making this a minor inconsistency.
Tool Count3/5
With 26 tools, the server is on the heavier end. The broad domain of automation, slideshow generation, video management, and TikTok publishing justifies many tools, but some redundancy (e.g., delete_schedule duplicates update_schedule's batch delete) makes it feel slightly over-scoped.
Completeness3/5
Automation and schedule CRUD are well covered, and the creation-to-publishing pipeline works. However, there are no delete or update operations for videos or slideshows, and collections lack any management tools beyond listing. These gaps prevent full lifecycle management for generated content.
Average 4/5 across 26 of 26 tools scored. Lowest: 3.3/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 2 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must disclose safety and side-effect behavior. It only says 'Get full details' without explicitly confirming read-only operation, error handling, auth requirements, 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences plus an Args block, front-loading the primary purpose with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple getter nature with one parameter and no output schema, the description adequately covers the return scope ('including all slideshow images') but lacks details on errors or data structure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description's 'profile_id: The profile ID' merely restates the schema's title. It adds no additional semantics like format, source, or validation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves a slideshow library profile with images, using the verb 'Get' and specifying the resource. It distinguishes from sibling getters by focusing on library profiles specifically.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as search_library or get_collection_images. The description offers no context about scenarios, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden for behavioral disclosure, but it only lists return content and does not mention auth requirements, side effects, error behavior, or explicitly confirm read-only semantics. The 'Get' verb implies read-only, but the description does not elaborate on any behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The main description is concise and front-loaded with a clear sentence. The redundant 'Args' block adds little value beyond the schema, but it is brief and does not hinder readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description provides key information about the return content (full details, slideshow images, TikTok publish status) for a simple single-parameter read tool. However, without an output schema or mention of permissions/limitations, it is not exhaustive but adequate for the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description restates the parameter name and adds minimal context ('The video ID.') without explaining format, source, or semantics. Since schema description coverage is 0%, the description should compensate but does not add much beyond the schema property title.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb ('Get') and resource ('full details for a single video'), and highlights key included content (slideshow images and TikTok publish status). This distinguishes it from sibling tools like list_videos or get_video_analytics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving details of a single video, but offers no explicit guidance on when to use it versus alternatives or any exclusions. It does not mention sibling tools or specific scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It states the operation is a removal but does not mention irreversibility, potential side effects, required permissions, or behavior when the job does not exist. As a destructive operation, this lack of disclosure 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, with a clear action statement followed by brief parameter definitions. Every sentence provides essential information, with no filler or repetition. Structure is efficient and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with only two parameters and no output schema, so the description adequately explains the core function. However, it lacks information about return values, error handling, or idempotency, which would be helpful for a delete operation. The absence of annotations and output schema means the description is the only source of behavioral information, leaving some gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, but the description compensates by defining each parameter: 'automation_id: The automation UUID' and 'job_id: The job to remove.' This adds meaningful context about the purpose and format of each parameter, though it could be more detailed about constraints or examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action: 'Remove a single schedule job from an automation.' It uses a specific verb ('Remove') and identifies the resource (schedule job within an automation), distinguishing it from sibling tools like delete_automation which removes the whole automation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide any guidance on when to use this tool versus alternatives. It does not mention delete_automation or update_schedule, nor does it specify any prerequisites or scenarios where this tool would be preferred. No usage context is provided beyond the basic action.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only restates the basic purpose and does not mention any behavioral traits such as return format, error conditions, permissions, rate limits, or side effects. The verb 'get' implies a read operation, but no specifics are given about what 'full details' includes, leaving the agent without useful contextual information.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, with two short sentences. The first sentence states the purpose, and the second provides parameter details. It is appropriately sized for a simple get operation and delivers information efficiently without unnecessary fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of an output schema and annotations, the description should explain what 'full details' means or what the response will contain. It does not. The single parameter is documented, but the tool's return value, error behavior, and usage context are absent. The description is insufficient for an agent to fully anticipate the outcome of the call.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema only specifies `automation_id` as a string with no description. The description adds the semantic that it is 'The automation UUID,' providing the expected format and meaning. This compensates for the 0% schema coverage and is valuable for correct invocation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Get full details of a single automation.' The verb 'Get' is specific, and the phrase 'single automation' distinguishes it from `list_automations`, which lists multiple automations. This is a precise and unambiguous purpose statement.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage: when you need full details of one automation by ID. However, it does not explicitly mention alternatives or when not to use it, nor does it compare with `list_automations` or other sibling tools. The context is clear but there are no explicit exclusions or alternative recommendations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full burden of behavioral disclosure. It does mention pagination and the limit max (100), which is useful context. However, it does not explicitly state that this is a read-only operation, describe the return format, or address error behavior (e.g., invalid collection_id).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exceptionally concise: one clear sentence plus a simple arg list. It front-loads the primary purpose and includes essential parameter details without any wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no output schema or annotations, the description is brief but somewhat adequate: it covers the basic action and parameters. However, it omits the return value structure (what an 'image' object contains), potential error scenarios, and any relation to sibling tools, leaving gaps that an agent must guess.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, so the description's parameter notes add important meaning: 'limit' is described as 'Max results (default 100, max 100)' and 'offset' as 'Pagination offset'. However, the stated default of 100 conflicts with the schema's default of null, creating ambiguity. The description adds some value but the inconsistency weakens it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action ('Get images') and resource ('in a collection'), with the pagination detail distinguishing it from simple list tools. It is specific and unambiguous, and the name reinforces the purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like search_library or list_collections. It does not mention any exclusions, prerequisites, or related tools, leaving the agent to infer usage purely from the name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden for behavioral disclosure. It only mentions 'List' and 'connected via OAuth,' but does not explain whether this is a read-only operation, whether there are any side effects, how results are paginated, or what data is returned. This is a significant gap for a tool listing accounts.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one short sentence that communicates the core purpose without wasted words. It is appropriately sized for a zero-parameter tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
While the description is clear and concise, it lacks any mention of return format, potential limitations, or the meaning of 'connected via OAuth.' Given the absence of an output schema and annotations, the description could be slightly more informative, but for a simple list operation it is minimally adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the input schema confirms an empty object. The description adds no parameter details, but none are needed; the baseline score of 4 applies because there is nothing to explain.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'List' and names the resource 'TikTok accounts connected via OAuth.' This clearly distinguishes it from sibling tools like list_tiktok_posts and get_account, which target different resources or operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no information about when to use this tool, what prerequisites exist, or how it differs from alternatives. It neither states exclusions nor suggests alternative tools, leaving the agent without guidance on tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It only says 'List,' which implies read-only, but doesn't explicitly state safety, authentication requirements, rate limits, or any side effects. It also doesn't explain aggregation behavior or timezone handling for timeframe.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded. It uses a single sentence for the purpose and a bullet-like list for parameters, with no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a list tool with 5 optional params and no output schema, the description covers parameters well but lacks details on the return structure beyond 'engagement metrics and aggregated statistics.' It also doesn't mention pagination behavior or rate limits, which may be important for a list operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant meaning by specifying allowed values for timeframe (7, 30, 90, 'all'), sort options, and default/max for limit, plus the meaning of offset and filter. This fully compensates for the schema's 0% coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it 'List TikTok posts with engagement metrics and aggregated statistics,' using a specific verb and resource that distinguishes it from sibling tools like list_videos or list_tiktok_accounts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives. The sibling list_videos and get_video_analytics could overlap, but the description doesn't mention them or any exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions 'rendered' and lists filters, but does not disclose return format, pagination behavior, sorting, or any side effects. For a read-only list tool, this is a notable gap given there is no output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single useful opening sentence followed by a parameter list. Each parameter is one line, and it is front-loaded with the purpose. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Parameter semantics are thorough, but the description lacks details about the response structure (fields returned) or pagination behavior beyond limit/offset. Given no output schema, this is a gap for a list operation. It is adequate but not complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The Args section adds substantial meaning beyond the bare schema. For example, video_type is enumerated ('slideshow', 'ugc', 'greenscreen'), limit has a default and max, and created_after/before specify ISO 8601. This fully compensates for the 0% schema description coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and resource ('rendered videos') with optional filters. This clearly distinguishes it from sibling tools like get_video (single retrieval) and list_automations (different resource type).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context through 'optional filters' (e.g., filter by automation, status), but it does not explicitly state when to choose this tool over alternatives like get_video or get_video_analytics. No exclusionary guidance is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full transparency burden. It discloses key constraints (at least one filter required, limit max 3, sort options) and parameter semantics, but omits details about return format, rate limits, or auth needs. It does not contradict annotations since none exist, but it doesn't fully describe behavior either.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured: a one-sentence purpose, an important requirement, and a terse args list. Every line provides necessary information, with no filler. The format is easily scannable, though slightly longer than strictly necessary.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 8 parameters, no output schema, and no annotations, the description provides solid coverage: it defines param semantics, enforces a filter requirement, and notes limit bounds. It lacks return-value details but is otherwise quite complete for a search tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, and the description fully compensates by explaining every parameter: q ('Text search across slide content'), niche, product_medium, region ('Account region code'), audience_region, sort ('"followers" or "recent"'), limit ('Default 3, max 3'), and offset ('Pagination offset'). This adds substantial meaning beyond the bare schema names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as 'Search real TikTok slideshow profiles for inspiration and competitive research,' naming the specific resource ('library') and intent. It distinguishes from generic search but doesn't explicitly contrast with sibling tool search_pinterest, so a slight differentiation gap remains.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some usage context ('for inspiration and competitive research') and a critical constraint ('At least one filter is required'), but it doesn't mention when to prefer this over alternatives like search_pinterest or when not to use it. This is 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.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the full burden of behavioral disclosure. It mentions 'recurring' and 'generates and publishes' but does not disclose side effects such as whether creation immediately triggers publishing, whether it returns an automation ID, or what preconditions are required. For a mutation tool, this is a notable gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured: a single front-loaded purpose sentence followed by a compact parameter list. Every parameter line adds value without unnecessary prose, and the format makes information easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 9 parameters, no annotations, and no output schema, the description covers the core purpose and all parameter semantics. However, it omits the return value, potential immediate execution behavior, and prerequisites like having valid TikTok account/product references, so it is not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, yet the description explains all 9 parameters with meaningful detail. It provides a concrete example for schedule, timezone information, source for tiktok_account_id, and clarifies nested object purposes like image_settings and tiktok_post_settings. This fully compensates for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Create a recurring automation that generates and publishes slideshows to TikTok on a cron schedule.' This clearly defines the tool's function and distinguishes it from sibling tools like list_automations, get_automation, delete_automation, and run_automation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly states the tool's purpose and cron scheduling context, but it does not explicitly contrast it with immediate-action tools like run_automation or publish_video_via_automation. Usage is implied rather than directly guided with alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It adds behavioral context by noting the video must be published and lists the returned metrics. However, it omits potential need for authentication, rate limits, or specifics about the response format, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, with the core purpose in the first sentence, followed by a necessary prerequisite and a simple args section. Every sentence earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no output schema, no annotations), the description covers the essential aspects: purpose, key metrics, prerequisite, and parameter. It lacks deeper context such as permission requirements or error behavior, but those are not critical for this straightforward read operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. However, it only restates the parameter name ('video_id: The video ID') without adding format, source, or additional clarification beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get') and clearly names the resource ('TikTok post analytics') with the exact metrics returned (views, likes, comments, shares, bookmarks). This distinguishes it from sibling tools like list_videos, get_video, and list_tiktok_posts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description states a clear prerequisite: the video must have been published to TikTok. It does not explicitly name alternatives or when-to-use vs. when-not-to-use, but the prerequisite provides enough context to guide usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It transparently discloses that the deletion is 'permanent' and cascades to 'all its scheduled jobs', which is critical for a destructive operation. No contradictions 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences—a clear action statement and a simple parameter definition—with no fluff. The Args block is conventional and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple delete tool with one parameter, the description covers the action, the parameter format, and the primary side effect. It lacks an explicit note on return values or error behavior, but the tool's simplicity and no output schema make this acceptable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides only the parameter name and type (string). The description adds that automation_id is 'The automation UUID', which clarifies the expected format though it does not specify where to obtain it or details like requiredness (already in schema). This is minimal additional meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'delete' with resource 'automation' and explicitly states 'all its scheduled jobs' are removed, clearly differentiating it from sibling tools like delete_schedule. The verb+resource+scope is immediately understandable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly state when to use this tool versus alternatives like delete_schedule or update_automation. However, the naming and description make the use case clear: permanent removal of an automation and its scheduled jobs, implying use when an automation is no longer needed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It communicates a read-only list operation with user scoping, but omits details like output format, pagination, or ordering. For a simple list tool this is acceptable but not deeply transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no wasted words. It immediately states the action, resource, and scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter list tool, the description adequately covers the purpose and scope. Since there is no output schema, it could benefit from explicitly stating the return type (e.g., 'returns an array of collection objects'), but 'List all image collections' is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has no parameters, and the schema is empty with 100% coverage. Per calibration, 0 params merits a baseline of 4. The description correctly implies no arguments are needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List'), the resource ('image collections'), and the scope ('belonging to the authenticated user'). This distinguishes it from sibling list tools like list_automations and list_videos, and from get_collection_images which gets images inside a collection.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The usage is implied: use when you need to list the authenticated user's image collections. However, it does not explicitly name alternatives or state when not to use it. A brief mention of sibling tools (e.g., 'For images within a collection, use get_collection_images instead') would improve this.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 conveys a read-only listing operation and notes that profile counts are included, but it does not disclose details like whether results are paginated, sorted, or restricted in any way.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that immediately communicates the tool's purpose. It contains no redundant words or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple no-argument listing tool with no output schema, the description adequately explains what will be returned (niches and profile counts). It lacks some context about what exactly constitutes a niche or the slideshow library, but the name and sibling tools provide reasonable context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the empty input schema is fully described. Per the baseline for 0-parameter tools, the description need not add parameter details; it already identifies the output concept (niches with profile counts).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and identifies a clear resource ('available niches in the slideshow library') with an outcome ('with profile counts'). This distinguishes it from sibling tools like list_collections and search_library.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this tool is used when you need to list available niches, but it provides no explicit guidance on when to choose this tool over alternatives such as search_library or list_collections. No exclusions or alternative names are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the timezone behavior for cron expressions, which is useful, but it does not mention permissions, failure conditions, or whether an existing automation is required. The behavior is minimally transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences plus an args listing, with no filler. It is front-loaded with the main action and structured cleanly for parameter details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter add tool with no output schema, the description covers the essential purpose and parameter details. It could mention prerequisites (e.g., automation must exist) but is otherwise complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, but the description fully explains both parameters: automation_id is 'The automation UUID' and cron is a 'Cron expression in Pacific time' with an example. This fully compensates for the schema's lack of detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Add a new cron schedule to an automation' with a specific verb ('Add'), resource ('schedule'), and scope ('to an automation'). The word 'new' distinguishes it from update_schedule and delete_schedule among siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The verb 'Add' implies use when creating a new schedule, but there is no explicit guidance on when not to use it or mention of alternatives like update_schedule. The usage context is implied rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal that the actions array supports both 'update' and 'delete' operations, which is significant behavioral context. However, it does not address potential side effects, permissions, or outcome details such as partial success in batch operations, leaving gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with a concise purpose statement, followed by mode-specific instructions and an Args list. The Args list partially repeats the earlier prose, but the overall structure is clear and scannable. It is appropriately sized and not overly verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity, the description covers the two operation modes, parameter roles, and the action type enum. It lacks explicit return-value information, but the absence of an output schema reduces that burden. It does not mention error conditions, but the fundamental invoke patterns are sufficiently described for an agent to use the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It does so effectively: automation_id is identified as the automation UUID, job_id as the job to update, cron as the new cron expression, and actions as an array of batch operations with structure [{type: 'update'|'delete', job_id, cron}]. All four parameters are explained, and the single-vs-batch distinction clarifies parameter relevance.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb-resource pair ('Update one or more schedule jobs on an automation'), clearly distinguishing it from sibling tools like add_schedule or delete_schedule. It also mentions batch operations, providing a full scope of the tool's capabilities.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states two usage modes: single update with job_id and cron, and batch operations with an actions array. This provides clear when-to-use guidance for different scenarios. It doesn't explicitly mention alternatives, but the modes themselves suggest the appropriate use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. 'List' implies a read-only operation and the scope to the authenticated user is stated, but it does not describe any side effects, return format, or limitations (e.g., pagination, sorting). This is adequate for a simple list operation but not rich in behavioral detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that immediately states what the tool does. It is front-loaded, concise, and contains no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple no-parameter list tool, the description adequately conveys the resource and scope. However, since there is no output schema and no annotations, the description could have mentioned the return structure (e.g., array of automation objects) to be fully complete. Overall, it is sufficient for the tool's low complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema description coverage is 100%. The description correctly omits parameter details because none exist. Per the rubric, 0 params warrants a baseline of 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'list' with a clear resource 'automations' and scope 'belonging to the authenticated user.' It clearly distinguishes from sibling tools like get_automation (single resource), create_automation, and delete_automation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies when to use this tool: when you need all automations for the authenticated user. However, it does not explicitly exclude alternatives or mention when to prefer other tools like get_automation for a single automation. The context is clear but lacks explicit 'when not to use' guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It does disclose pagination up to 5 pages per query and explains the cursor parameter, but does not explicitly state that this is a read-only operation, mention authentication needs, or describe the response format. The safety profile is implied but not stated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: a one-sentence summary, a note on pagination, and a clear args list. Every sentence adds value, and it is front-loaded with the main purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter search tool with no output schema, the description covers purpose, pagination, and both parameters. It does not detail the return structure, but the core use case is clear and the tool is not overly complex. The lack of output schema and annotations makes it slightly incomplete, but acceptable for the scope.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, but the description provides an `Args` list that explains `q` with an example ('aesthetic coffee') and defines `cursor` as 'Pagination cursor from a previous response.' This adds meaningful context beyond the schema's bare parameter names and types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Search Pinterest for high-resolution images to use in slideshows,' which specifies the verb (search), resource (Pinterest), and intended use case. This distinguishes it from sibling tools like search_library and get_collection_images.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool (to find high-resolution images for slideshows) but does not explicitly mention alternatives or exclusions. It implies the use case rather than specifying when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the behavioral disclosure burden. It discloses the async nature ('Rendering is async (~45s)') and the AI-driven selection of text/images/styling, which are important behavioral traits. It does not mention potential side effects, permissions, or failure modes, but the disclosed information is valuable and not redundant.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded, with the main purpose in the first sentence, followed by the async note and then a clearly formatted Args section. Every sentence is purposeful, with no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 2-parameter tool with no output schema, the description covers the core functionality, parameter semantics, and the next step (polling slideshow_status). It does not specify the initial response format or error handling, but given the tool's simplicity and the async pointer, it is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must fully explain parameters. The 'Args' section does this well: it explains additional_context (controls topic, slide count, text, fonts, tone, etc.) and images (optional background URLs, 0-indexed mapping). This adds significant meaning beyond the bare schema names and types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Generate a slideshow from a natural-language prompt.' It also adds a distinguishing detail, 'AI picks text, images, and styling,' which separates it from sibling tools like create_slideshow by emphasizing the AI-driven generation from a prompt.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (provide a natural-language prompt and optionally images) and gives a post-usage instruction ('Poll slideshow_status to track progress'), but it does not explicitly differentiate when to use this tool versus the sibling create_slideshow or other slideshow tools. There are no exclusions or alternative recommendations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of disclosing behavior. It explains the pause/unpause mechanics and field replacement semantics, but does not mention potential side effects, permission requirements, or state-dependent behavior (e.g., whether an already paused automation can be paused again).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear main purpose, mode-specific instructions, and a compact arg list. Each sentence adds value, and the front-loaded summary makes it easy to scan quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 10 parameters and no annotations or output schema. The description covers all parameters and mode usage, but lacks information about edge cases like invalid state transitions or error conditions. Overall, it is fairly complete for a complex mutation tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It provides explanations for all 10 parameters, including specific values for action, the replacement behavior for slideshow_hooks, and the meaning of each update field. This fully compensates for the schema's lack of descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool updates automation settings or pauses/unpauses it, using a specific verb and resource. It distinguishes itself from sibling tools like get_automation, delete_automation, and run_automation by focusing on update and pause/unpause operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly explains when to use action with 'pause' or 'unpause' and when to update config fields, including the mutual exclusivity of action. It does not explicitly mention alternatives, but the internal mode guidance is clear and sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden and does disclose useful behavioral traits: no AI generation, ~10 second render time, conditional video export behavior ('Only applies when export_as_video is true'), and overlay behavior. However, it does not mention the return format, authentication requirements, or any side effects beyond creation/rendering.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured: a one-sentence purpose, a brief behavioral note, then a compact parameter list with defaults and conditions. Every line adds value and no filler is present.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 10 parameters, 0% schema description coverage, no output schema, and no annotations, the description is quite complete for invoking the tool. It explains all parameter semantics and conditions. The main gap is not describing what the tool returns (e.g., a slideshow ID or rendered asset URLs), which would be useful for the agent to handle the result.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description's parameter list adds substantial meaning: defaults, allowed values, conditional behavior, and per-slide structure. It covers all 10 parameters, though the slides parameter is only partially explained with 'etc.', leaving the nested slide schema somewhat vague.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool creates a slideshow with full manual control, and explicitly distinguishes itself from AI generation ('No AI generation'), which separates it from the sibling generate_slideshow. The verb+resource and scope are specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the right use case ('full manual control') and excludes AI generation ('No AI generation — renders in ~10 seconds'). It gives clear context but does not explicitly name the alternative tool (generate_slideshow) or state explicit 'use when / don't use when' instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the rate limit, draft mode behavior, and parameter-specific constraints (e.g., caption max 89 chars, visibility enum values). It lacks error handling or permission details but provides substantial behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a header, note, and args list. Each parameter gets a concise line. It is slightly long due to the parameter count, but every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (15 params, no output schema, no annotations), the description is quite complete: it covers all inputs, the rate limit, and suggests a draft alternative. It omits return value/error behavior, but the coverage is strong for the complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description compensates fully by explaining all 15 parameters, including default values, allowed enum values for visibility, post_mode, and upload_type, and character limits. This adds essential meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description explicitly states 'Publish a completed video to TikTok with all settings provided directly (no automation needed)', giving a specific verb and resource. It also distinguishes from automation-based tools by highlighting 'no automation needed'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Mentions 'no automation needed' to differentiate from automation flow, and gives explicit guidance about TikTok's 6-publish limit: 'Use MEDIA_UPLOAD (draft) to avoid this.' However, it does not directly name alternative sibling tools like publish_video_via_automation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Given no annotations are provided, the description carries the full disclosure burden. It accurately describes the information returned, implying a read-only operation, and does not hide any side effects. There are no behavioral surprises for a simple account info getter.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that front-loads the verb and lists the key details. Every word earns its place, with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a no-parameter, no-output-schema tool, this description fully captures its behavior and output. It specifies exactly what account info will be retrieved, making it complete within the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so the description automatically meets the baseline for parameter semantics. The description adds value by listing the specific account fields returned, which is more than the empty schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves account information and specifies key fields (subscription tier, remaining credits, billing cycle reset date). This makes the tool's purpose instantly clear and distinguishes it from the content-centric sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description establishes that this tool is appropriate for obtaining account-level details. While it doesn't mention alternatives, no sibling tool serves the same purpose, so the usage context is clear and unambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 discloses that the tool uses the automation's saved settings, that the video must be completed, and that post_mode defaults to the automation's setting. However, it does not mention reversibility, permissions, or response/error behavior, which is a gap for a mutating publish action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded, with a two-sentence overview followed by an Args list. No wasted words; every sentence adds information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description covers purpose, usage conditions, and parameter details. It lacks return-value or error-case information, but it is sufficient for an agent to select and invoke the tool correctly in most cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description compensates by defining both parameters: video_id must be a completed video ID, and post_mode specifies DIRECT_POST or MEDIA_UPLOAD with TikTok draft semantics and default behavior. This adds meaningful guidance beyond the raw schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Publish a completed video to TikTok using the automation's saved settings' with a specific verb and resource. It distinguishes from the sibling publish_to_tiktok by explicitly naming it as the standalone alternative.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly states 'The video must be linked to an automation' and directs 'For standalone publishing, use publish_to_tiktok instead.' This provides a clear condition and alternative, satisfying when-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the status flow (draft → generating → rendering → completed/failed) and conditional return of video_id/video_status. This is good behavioral context, though it doesn't explicitly state read-only nature or side effects (which are minimal for a status check).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (4 sentences) and front-loaded with the purpose. The status flow line and args section are efficient with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter status tool, the description is fairly complete: it covers the polling interval, status flow, and when video info appears. However, it lacks explicit mention of the main return fields (e.g., status, progress) beyond the conditional video info, which matters since there is no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides zero description for slideshow_id (0% coverage). The description compensates fully by explaining the parameter is 'The slideshow ID from generate or create', giving the source and expected value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool checks 'slideshow generation/rendering progress', with a specific verb and resource. It distinguishes from siblings like generate_slideshow and create_slideshow by focusing on status polling.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear usage context: poll every 5-10 seconds, and explains the slideshow_id comes from generate or create. However, it doesn't explicitly mention when not to use it or name alternative tools for related operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that the run is asynchronous (via polling instructions), that it does not affect the cron schedule, and that 'mode' can produce a video or draft only. It does not mention potential side effects like cost or permission requirements, but covers key behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and efficient: a clear opening statement, a key behavioral caveat, a practical polling tip, and a concise parameter list. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a trigger tool with no output schema and no annotations, the description fully equips the agent: it explains the action, the non-effect on schedules, how to locate the resulting video, and the meaning of each parameter. Nothing critical is missing for successful invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Despite 0% schema description coverage, the description explains all three parameters: automation_id is the UUID, hook overrides the hook/topic, and mode specifies 'export' vs 'draft_only'. This adds substantial meaning beyond the bare schema types and defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool triggers a one-off slideshow generation using saved settings, with specific verb 'Trigger' and resource. It distinguishes itself from schedule-related tools by noting it does not affect the cron schedule, and from synchronous generation tools by describing polling behavior.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context by stating 'Does not affect the cron schedule', implying when to use this tool vs. schedule modifications, and gives a polling workflow for retrieving the result. However, it does not explicitly name alternative tools (e.g., generate_slideshow or update_automation), only implied exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![reelfarm-mcp MCP server](https://glama.ai/mcp/servers/AhmadElsaeedd/reelfarm-mcp/badges/card.svg)](https://glama.ai/mcp/servers/AhmadElsaeedd/reelfarm-mcp)

Score Badge

Copy to your README.md:

[![reelfarm-mcp MCP server](https://glama.ai/mcp/servers/AhmadElsaeedd/reelfarm-mcp/badges/score.svg)](https://glama.ai/mcp/servers/AhmadElsaeedd/reelfarm-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/AhmadElsaeedd/reelfarm-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server