Social captions + hashtags via MCP — no LLM in the loop
Scored across 3 tools
Each tool targets a distinct verb+resource: check_balance reads account state, generate_captions performs the core generation action, and mint_free_trial handles key provisioning. The descriptions explicitly scope when to use each (e.g. only call mint_free_trial without a configured key), leaving no realistic overlap.
All three names follow a strict verb_noun snake_case pattern (check_balance, generate_captions, mint_free_trial). There is no mixing of conventions or vague verbs.
Three tools is on the thin side but well-matched to a narrow caption-generation API; every tool earns its place. A couple of auxiliary operations (e.g. listing templates or tiers) could be added without bloat, so it falls just short of ideal breadth.
The surface covers the full lifecycle for a stateless generation service: obtain a key, check credits, and generate captions. Minor gaps exist around key management (rotation, account/tier details beyond expiry) but the core agent workflow has no dead ends.
Use before generating when you're unsure the key still has credits, or when the user asks about their plan, tier, or expiry.
Shows remaining API credits, key tier, and expiry.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. 'Shows' implies a non-mutating read, and it discloses the three returned fields, but it never explicitly states that the call has no side effects, nor does it mention auth requirements or rate limits. Adequate for a zero-argument read tool, but not rich.
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, front-loading the usage trigger before the return summary. Every clause carries information and nothing is padded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With zero parameters and an output schema already documenting return shape, the description supplies the only missing piece an agent needs: when to reach for this tool versus proceeding to generation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so the baseline of 4 applies; there is no parameter surface for the description to clarify or compensate for.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Shows remaining API credits, key tier, and expiry') and implicitly scopes itself against the generate_captions sibling by framing its use as a pre-generation check. An agent can tell what this returns without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives two concrete triggering conditions: uncertainty about remaining credits before generating, and user questions about plan, tier, or expiry. It does not name an alternative for the zero-credit case (mint_free_trial is the obvious next step but goes unmentioned), so it stops short of full when/when-not routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Use when the user wants ready-to-post social captions — hooks, post bodies, CTAs, and hashtags as JSON for LinkedIn, Instagram, TikTok, or X.
Deterministic template engine (no LLM): best for on-brand, repeatable
captions, not open-ended creative writing.
tone: warm | bold | professional | playful
platform: linkedin | instagram | tiktok | x
count: 1-10 captions. Costs 1 API credit per call.
| Name | Required | Description | Default |
|---|---|---|---|
| tone | No | warm | |
| count | No | ||
| topic | Yes | ||
| audience | Yes | ||
| platform | No | ||
| include_hashtags | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and discloses the two traits an agent most needs: the engine is deterministic/template-based (no LLM), and each call costs 1 API credit. It also states the return shape is JSON. It does not cover auth requirements, rate limits, or failure behavior, so it falls short of a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loads the trigger condition, then the key behavioral differentiator, then the parameter reference list. No wasted sentences, though the mid-sentence line breaks make the first paragraph read awkwardly.
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?
An output schema exists, so return values need no prose, and the description still usefully names cost and the deterministic engine. For a simple six-parameter generator the remaining gap is the undocumented required params and any auth expectation, which keeps it from a 5.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description is the only source of parameter documentation and it does supply the allowed values for tone (warm|bold|professional|playful), platform (linkedin|instagram|tiktok|x), and the count range (1-10). However, the two required parameters, topic and audience, receive no explanation at all, leaving half the contract undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource (generate captions) plus the exact output composition — hooks, post bodies, CTAs, hashtags as JSON — and the supported platforms. An agent can distinguish this instantly from siblings check_balance and mint_free_trial, which share no domain.
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?
Opens with an explicit trigger ('Use when the user wants ready-to-post social captions') and adds a clear negative case ('Deterministic template engine (no LLM): best for on-brand, repeatable captions, not open-ended creative writing'). Both the when and the when-not are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Use when no API key is configured and the user wants to try Caption-Pack free. Only call after the user agrees to the free tier — never mint silently.
Mints a 25-call trial API key (no card, no account).
Abuse guards: one key per IP per day, 7-day expiry, free keys can never
convert to paid. The key is shown ONCE — save it as CAPTIONPACK_API_KEY
immediately.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and delivers: abuse guards (one key per IP per day), 7-day expiry, no paid conversion, and a single-display key that must be saved immediately. These are consequential behaviors an agent could not infer from the schema.
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?
Usage condition comes first, then mechanism, then guards, then the critical save instruction. Every sentence is load-bearing; nothing is restated for padding.
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?
An output schema exists, so return-value explanation is unnecessary, and the description still covers side effects (rate limit, expiry, non-convertibility) and the one-time key handling. Nothing an agent needs to call this safely is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so the baseline is 4 and there is no parameter semantics for the description to compensate for. It does not need to describe inputs, and it doesn't waste words doing so.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource — mints a 25-call trial API key — with concrete scope (25 calls, no card, no account). It is instantly distinguishable from siblings check_balance and generate_captions.
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 names the trigger condition (no API key configured, user wants to try the free tier) and adds a hard exclusion: only call after the user agrees, never mint silently. This is exactly the when/when-not guidance an agent needs before invoking a provisioning tool.
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.
check_balancegenerate_captionsmint_free_trial
Add one secure layer between your agents and this server.