This server lets an AI agent manage a Kadenzo social media workspace: schedule, edit, cancel, and analyze posts across 11 platforms, plus run social listening and DM automation.
Account management: list_accounts to see connected social accounts (id, platform, username).
Post scheduling: schedule_post with future time, multiple accounts, media, per-platform content/options, and dry-run (validate_only).
Post lifecycle: list_posts, get_post to inspect; update_post to edit before publish; cancel_post to cancel a scheduled post.
Media upload: upload_media to convert a local file to a hosted URL for use in posts.
Analytics: get_account_analytics (recent posts + engagement) and get_post_analytics (per-channel metrics) for performance insights.
Content generation: generate_content writes copy for Instagram, TikTok, Snapchat, Facebook, or YouTube from a topic and goal.
Best times: get_best_times provides personalized posting times (Professional+ plan) to optimize scheduling.
Social listening: list_mentions, list_keywords, add_keyword, update_keyword, delete_keyword to track and manage brand mentions, and get_listening_analytics / get_share_of_voice for volume/sentiment analysis.
Engagement: post_comment to reply on Instagram, Facebook, or LinkedIn posts.
DM automation: create_dm_automation, update_dm_automation, delete_dm_automation, list_dm_automations to build rules (comment→DM, keyword DM, links, etc.) and view funnel stats.
Allows scheduling, managing, and analyzing social media posts on Bluesky.
Allows scheduling, managing, and analyzing social media posts on Facebook.
Allows scheduling, managing, and analyzing social media posts on Instagram.
Allows scheduling, managing, and analyzing social media posts on Mastodon.
Allows scheduling, managing, and analyzing social media posts on Pinterest.
Allows scheduling, managing, and analyzing social media posts on Telegram.
Allows scheduling, managing, and analyzing social media posts on Threads.
Allows scheduling, managing, and analyzing social media posts on TikTok.
Allows scheduling, managing, and analyzing social media posts on YouTube.
Connect any MCP-capable AI agent — Claude Desktop, Cursor, ChatGPT, Codex — to Kadenzo and let it schedule, manage, and analyze social posts across 11 networks (Instagram, TikTok, X, LinkedIn, YouTube, Facebook, Pinterest, Threads, Bluesky, Mastodon, Telegram). It wraps the Kadenzo Studio public API as Model Context Protocol tools, so your agent doesn't just draft content — it can ship it.
Tool | What it does |
| List connected accounts (ids + platforms) |
| Schedule a post for a future time (+ |
| List your posts, newest first (filter by status, paginate) |
| One post: status, per-channel outcome, options/thread |
| Edit a not-yet-published post |
| Cancel a scheduled post before it publishes |
| Upload a local image/video file, get a URL for |
| Recent posts + engagement metrics for an account |
| Per-channel metrics for a post you scheduled |
| Generate post copy for a platform from a topic ("generate then schedule") |
| Personalized best posting times for an account (Professional+) |
| Social-listening mentions (who's talking about your keywords) |
| Post a comment/reply to your post (instagram/facebook/linkedin) |
| List the social-listening keywords you track |
| Track a new listening keyword (per-plan caps apply) |
| Edit a keyword, or pause/resume it with |
| Stop tracking a keyword |
| Mention volume, platform split, sentiment over time |
| Brand vs competitor Share of Voice report (Enterprise) |
| DM automation rules + funnel stats + contact usage |
| Create a DM automation rule (comment→DM, keyword DM, DM links, …) |
| Edit a rule, or pause/resume it with |
| Delete a DM automation rule |
Related MCP server: @posteverywhere/mcp
Generate an API key in Kadenzo: Settings → API keys (studio.kadenzo.app/dashboard/settings?section=api). The API is available on paid plans.
Add the server to your MCP client. Claude Desktop (claude_desktop_config.json) / Cursor (~/.cursor/mcp.json):
{
"mcpServers": {
"kadenzo": {
"command": "npx",
"args": ["-y", "kadenzo-mcp"],
"env": { "KADENZO_API_KEY": "kdz_live_xxxxxxxxxxxxxxxxxxxxxxxx" }
}
}
}Restart the client. Ask your agent things like "list my connected accounts," "schedule this to X and Bluesky tomorrow at 9am," or "how did my last Instagram posts perform?"
Posts are schedule-only — provide a future scheduled_for; they publish automatically.
KADENZO_API_BASE overrides the API base URL (default https://studio.kadenzo.app/api/v1).
Requires Node 18+ (uses the built-in fetch/FormData).
Learn more / full API reference: https://studio.kadenzo.app/developers · https://kadenzo.app
Cancel a scheduled post before it publishes. Already-published posts cannot be cancelled.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes |
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 key constraint (only scheduled posts, not published), but does not describe error behavior, idempotency, or any side effects beyond cancellation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no unnecessary words. Front-loaded with the action, then the constraint. Every sentence 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?
No output schema, so the description should explain return values or success/failure behavior. It does not. For a simple mutation tool, more context on outcomes is needed.
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 has one parameter 'id' with no description (0% coverage). The description adds no meaning to the parameter, failing to compensate for the lack of schema documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'cancel' and the resource 'scheduled post', with the distinction that already-published posts cannot be cancelled. However, it does not differentiate from sibling tools like schedule_post or update_post.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use (before publishing) and what not to use on (published posts), but lacks explicit guidance on alternatives or when to choose this over siblings. No mention of prerequisites or conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate post copy for a platform from a topic — great for a "generate then schedule" flow. Returns a caption/post/description you can feed into schedule_post. Platform must be one of: instagram, tiktok, snapchat, facebook, youtube.
| Name | Required | Description | Default |
|---|---|---|---|
| goal | No | Angle for the copy. Defaults to "story". | |
| topic | Yes | What the post is about (2-500 characters). | |
| platform | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It states the return format (caption/post/description) but does not disclose behavioral traits like idempotency, rate limits, or side effects beyond being a generative 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?
The description is two sentences, front-loaded with key purpose and usage, with no extraneous information. Highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description explains the return value and downstream use (schedule_post). Parameter info is partially covered; overall, the tool's purpose and workflow are well-documented.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 67%. The description adds the allowed platform values (already in schema enum) and implies topic meaning, but does not elaborate on goal parameter beyond what schema says. Adds some value but not substantial.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool generates post copy for a specific platform from a topic, and explicitly mentions it fits a 'generate then schedule' flow, distinguishing it from sibling tools like schedule_post.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context (generate then schedule) and specifies that the output can be fed into schedule_post, but does not explicitly state when not to use it, though the sibling list implies alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent posts and their engagement metrics for one connected account (likes, comments, views, etc.). The reliable analytics surface.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | 1-100, default 25. | |
| account_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. Description implies read-only but lacks details on data freshness, authorization requirements, or behavior with empty accounts. The promotional 'reliable' adds no substantive behavioral info.
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 concise sentences, front-loaded with main purpose. The second sentence is somewhat promotional but not overly verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and sibling tools, the description lacks detail on return format, error handling, and how it differs from get_post_analytics. Incomplete for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50%: limit has a brief description, account_id has none. Description mentions engagement metrics (likes, comments, views) but does not clarify parameter formats or usage. Some value added, but incomplete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it retrieves recent posts and engagement metrics for one connected account, which distinguishes it from siblings like get_post_analytics (single post) and list_posts (no analytics). However, it does not explicitly contrast with all siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives like get_post_analytics or get_best_times. The phrase 'reliable analytics surface' is not actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Personalized best posting times for one connected account, computed from its own engagement history. Requires the Professional plan or higher. Hours are UTC; shift to the poster’s timezone. Use it to pick scheduled_for.
| Name | Required | Description | Default |
|---|---|---|---|
| account_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses that the tool works for a single connected account, requires the Professional plan, and uses UTC timezone. It does not mention read-only status, rate limits, or what happens with insufficient engagement history.
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?
Three sentences, each adding value: purpose, plan requirement, and usage guidance with timezone. No redundancy or irrelevant information. Front-loaded with the core function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no output schema), the description covers purpose, constraints (plan, timezone), and a usage hint. Lacks explicit return format, but is largely complete for a tool that likely returns a list of times.
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 0%, so description must explain the parameter. It mentions 'one connected account,' implying account_id identifies the account, but does not explicitly state that it comes from list_accounts or provide examples. Adequate but not explicit.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns personalized best posting times for a connected account, based on engagement history. It distinguishes from broader analytics tools like get_account_analytics. However, it does not specify the exact format of the output (e.g., list of times), which slightly reduces clarity.
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 a usage hint: 'Use it to pick scheduled_for.' This implies the tool is meant to be used before scheduling posts. However, it does not explicitly contrast with alternatives like get_account_analytics or mention when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get one post: roll-up status, per-channel outcome, and any options/thread that were set on it.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | The post id. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It discloses the return structure (status, outcome, options/thread) but does not mention side effects, permissions, or idempotency. For a simple read, the lack of explicit safety traits is a minor 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?
Single sentence with no wasted words. The structure is front-loaded with the verb 'Get' and efficiently conveys the scope.
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 get operation with one parameter and no output schema, the description adequately explains the return fields. However, it could mention the expected response format or any default behavior. It is minimally complete for a tool of this 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 coverage is 100% for the single 'id' parameter, so baseline is 3. The description does not add meaning to the parameter itself, but explains what is returned. No additional parameter context is provided beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool retrieves one post and lists specific fields returned (roll-up status, per-channel outcome, options/thread). It distinguishes from siblings like list_posts and get_post_analytics by specifying the granularity and exact data, aiding agent selection.
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 explicit guidance on when to use this tool versus siblings like list_posts (for multiple posts) or get_post_analytics (for analytics). The description implies it's for retrieving a single post but lacks usage context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Per-channel engagement metrics for a specific post you scheduled (best-effort; use get_account_analytics for the full picture).
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description adds 'best-effort' caveat hinting at potential data issues, but lacks details on side effects, idempotency, or failure behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with essential information, no wasted words.
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?
Minimally adequate for a single-parameter tool, but lacks description of output metrics and fails to compensate for missing output schema and annotations.
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 0% and the description does not explain the 'id' parameter's meaning or format, leaving the agent uninformed about what value to provide.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly describes fetching per-channel engagement metrics for a specific post, distinguishing it from the account-level sibling tool get_account_analytics.
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?
Explicitly advises using get_account_analytics for the full picture, providing when-to-use and alternative context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List the social accounts connected to this Kadenzo workspace — returns each account id, platform, and username. Use the ids as account_ids when scheduling.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It only lists what is returned but omits behavioral traits like read-only nature, pagination, or rate limits. A list operation with zero parameters should at least hint at being safe to call.
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?
Extremely concise: one sentence that covers purpose, output, and usage hint. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and no output schema, the description covers the core functionality. Could mention if all accounts are returned or if there is an active/inactive distinction, but it's sufficient for a simple lightweight 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?
No parameters, so baseline is 4. Description adds value by specifying the return fields, which compensates for empty schema. Schema coverage is 100% (no params), so description satisfies completeness.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it lists connected social accounts and explicitly mentions returned fields (id, platform, username). Distinguishes from sibling tools that deal with posts, comments, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides guidance on using the returned ids for scheduling, which is helpful downstream. No explicit when-not or alternatives, but the tool is simple with no parameters, so minimal ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Your social-listening mentions — who is talking about the keywords you track (reddit/bluesky/youtube/hackernews/…), newest first. Filter by platform, since (ISO), or unread.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| since | No | ISO datetime; only mentions published after this. | |
| offset | No | ||
| unread | No | ||
| platform | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses ordering (newest first) and filtering capabilities, but omits important behavioral details such as pagination (limit/offset behavior), error handling, data freshness, or any rate limits. This is insufficient for a listing tool with 5 parameters.
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 concise, consisting of a single sentence with key details upfront. It is not verbose and each phrase adds value. However, it could be more structured (e.g., listing parameters explicitly).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters, no output schema, and low schema coverage, the description is incomplete. It does not mention the return format, pagination behavior, or what fields each mention contains. This leaves gaps for an AI agent to correctly invoke the 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 only 20% (only 'since' described). The description adds meaning for platform, since, and unread parameters, but fails to explain limit and offset. This partially compensates for the schema gaps but not completely.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists mentions from social listening, specifying sources (reddit, bluesky, youtube, etc.) and ordering (newest first). It distinguishes itself from sibling tools like list_accounts or get_post by focusing on 'mentions' rather than posts or accounts.
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 mentions filtering options (platform, since, unread) indicating when to use these parameters, but does not explicitly state when not to use this tool or direct users to alternatives. The context is clear but lacks exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List your posts, newest first. Optionally filter by status (comma-separated, e.g. "pending,posted") and paginate with limit (1-100) and offset.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| offset | No | ||
| status | No | Comma-separated statuses, or omit for all. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses ordering behavior (newest first) and parameter usage (comma-separated status). Without annotations, it does not explicitly state read-only or auth needs, but for a list tool this is sufficient.
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 with 20 words, efficiently conveying purpose and optional parameters with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema but the description implies a list of posts. It covers ordering, filtering, and pagination. Could specify it returns the user's own posts, but context is adequate.
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 low (33%), but the description adds meaning to all parameters: limit (1-100), offset (pagination), status (comma-separated). This compensates for missing schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List your posts, newest first,' specifying the verb (list) and resource (posts) with ordering. It distinguishes from siblings like get_post (single post) and get_post_analytics.
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 explains optional filtering by status and pagination with limit and offset, providing clear context for use. It does not explicitly state when not to use or mention alternatives, but the sibling tools offer differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Post a comment/reply to one of your posts. account_id from list_accounts; target_id is the platform post/media/comment id to comment on. Supported: instagram, facebook, linkedin.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| target_id | Yes | The platform post/media/comment id to comment on. | |
| account_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Mentions it posts a comment/reply but does not disclose authentication requirements, rate limits, error handling, or potential consequences (e.g., irreversibility).
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?
Extremely concise: one sentence with essential information, no unnecessary words. Front-loaded with core action.
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?
Covers basic purpose and parameters but lacks return value information (no output schema) and error handling details. For a creation tool, it is adequate but could be more informative.
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?
Adds meaningful context beyond schema: account_id sourced from list_accounts, target_id explained as platform post/media/comment id. However, text parameter lacks any extra description (character limits, formatting). Schema coverage is low (33%), but description partially compensates.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the action: posting a comment/reply to one of your posts. It lists supported platforms (Instagram, Facebook, LinkedIn) and distinguishes from sibling tools (no other comment tool exists).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides guidance on parameter sources (account_id from list_accounts) and target_id definition. Lack of explicit when-to-use vs alternatives, but no competing sibling for commenting.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Schedule a social post to one or more connected accounts for a FUTURE time (it publishes automatically). Set validate_only=true to check accounts/limits/timing without scheduling.
| Name | Required | Description | Default |
|---|---|---|---|
| thread | No | Multi-post threads, e.g. {"x":["1/…","2/…"],"bluesky":["…"]}. | |
| content | No | Post text. Optional only if media_urls is provided. | |
| options | No | Per-platform format options, e.g. {"instagram":{"as_reel":true,"first_comment":"#tags"},"tiktok":{"privacy_level":"PUBLIC_TO_EVERYONE"}}. | |
| media_urls | No | Public image/video URLs, or URLs returned by upload_media. | |
| account_ids | Yes | Account ids from list_accounts (at least one). | |
| scheduled_for | Yes | ISO 8601 future datetime, e.g. "2026-07-02T09:00:00Z". | |
| validate_only | No | If true, validate only (dry run) and do not schedule. | |
| platform_content | No | Per-platform text overrides, e.g. {"twitter":"shorter text"}. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes scheduling for future time and automatic publishing, but lacks details on permissions, rate limits, error handling, or post-validation behavior. No annotations to supplement.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no redundancy, key info front-loaded. Every sentence adds value.
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 8 parameters, nested objects, and no output schema, the description is concise but omits return values, failure modes, and edge cases. Adequate but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% so baseline is 3. Description adds context for validate_only, but doesn't enhance understanding of other parameters beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states verb 'schedule' with resource 'social post' and specifies future time and automatic publishing. Distinguishes from sibling tools like cancel_post and get_post.
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?
Implies usage for scheduling future posts and mentions validate_only for dry runs, but does not explicitly state when not to use or alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Edit a post that has not published yet — change content, accounts, time, media, options, or thread.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | ||
| thread | No | ||
| content | No | ||
| options | No | ||
| media_urls | No | ||
| account_ids | No | ||
| scheduled_for | No | ||
| platform_content | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must disclose behavior. It states the tool edits only unpublished posts and lists changeable aspects, but does not cover auth requirements, error conditions, or side effects. Adequate but not comprehensive.
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 that is front-loaded with the key condition and lists changeable fields concisely. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 8 parameters, nested objects, and no output schema. The description does not explain return values, error conditions, or provide guidance on the complex thread parameter. Significant gaps remain for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description maps several parameter names to named changeable aspects (content, accounts, time, media, options, thread) but does not explain the structure of complex parameters like thread or platform_content, or the role of the required id.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the verb 'edit' and the resource 'post', with a specific condition 'that has not published yet', distinguishing it from sibling tools like schedule_post or cancel_post.
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?
Description implies usage only for unpublished posts but does not explicitly state when not to use it or mention alternative tools for published posts. The guidance 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.
Upload a local image or video file and get a hosted URL to use in media_urls when scheduling.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute path to a local image/video file. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility. It states the input is a local file and the output is a hosted URL, but lacks details on auth requirements, rate limits, file size restrictions, or whether uploads are destructive.
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 of 16 words, front-loaded with the action, no filler. Perfect conciseness.
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 one parameter, no output schema, and no annotations, the description covers the basics. However, it omits details like supported file formats, max file size, and whether the file must exist locally, which an agent would need to avoid errors.
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% with a single parameter well-described. The description adds the context that the path is for local image/video and the output is for scheduling, consistent with the schema. No significant extra meaning beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool uploads a local image/video file and returns a hosted URL for use in media_urls. It specifies the resource and action, distinguishing from sibling tools focused on posting and scheduling.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies using the tool before scheduling by mentioning the hosted URL for media_urls. However, it does not explicitly state when not to use it or mention alternative tools for handling media.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.3.2cancel_postgenerate_contentget_account_analyticsget_best_timesget_postget_post_analyticslist_accountslist_mentionslist_postspost_commentschedule_postupdate_postupload_mediaEach tool targets a distinct action—content generation, scheduling, analytics, listening, and engagement—with no functional overlap. Even similar tools like get_account_analytics and get_post_analytics are clearly differentiated by scope and usage guidance.
All tool names follow a consistent verb_noun snake_case pattern (e.g., generate_content, list_accounts, post_comment). Verbs like get/list are appropriately used for singles vs. multiples, and the pattern is uniform across all 13 tools.
13 tools cover the full social media scheduling lifecycle—content creation, media upload, scheduling, updates, cancellation, analytics, and social listening—without redundancy. The count feels well-scoped for a server of this purpose.
Core workflows (schedule, update, cancel, analytics) are fully covered. Minor gaps exist (e.g., no media deletion or account creation), but they are not essential for the primary scheduling use case and would likely fall outside the server's intended scope.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Post, schedule, and track social posts on X, Bluesky, LinkedIn, Instagram and more from AI agents.
Draft, schedule and publish social posts to nine platforms from any AI agent.
Schedule and publish social media posts to 9 platforms from your AI agent
Schedule, generate and publish social posts to X, LinkedIn, Instagram, Threads and YouTube
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Kadenzo/kadenzo-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
