AI Manga & Anime Generator - Mangii MCP

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint. The description adds useful context: it returns a URL, mentions funding apiPackCredits, and explains a key limitation. It does not contradict annotations and provides extra behavioral detail beyond what's in the annotations.

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

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

Three concise sentences, no fluff. The primary purpose is front-loaded, and every sentence adds relevant information (what, why, when to call).

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

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

For a simple read-only tool with an output schema, the description covers purpose, trigger condition, and the only parameter's significance. No missing critical information; the tool is self-contained and appropriate for its simplicity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining that the parameter's purpose influences the response field next_generation_credits, giving meaningful context beyond the schema's enum description.

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 'Return[s] the Console billing URL so a human can fund apiPackCredits,' specifying both the action and the resource. It differentiates from what the tool is not (Generate-scoped keys cannot create Checkout sessions) and is not a tautology.

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 tells when to call: 'Call this after 402 insufficient_credits.' It also implies the context (when API credits are insufficient) and the constraint that generate-scoped keys can't use Checkout, providing clear usage guidance even without naming sibling tools.

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

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

Annotations say readOnly=false and destructive=false, so this is a write operation. The description adds meaningful behavioral context: default panel identity/scene mapping, override semantics, and credit cost parity with create. It does not describe the return payload, but an output schema exists, so that burden is already covered.

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

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

Four short sentences with no filler. The core action is front-loaded, and each sentence carries operational value: the default behavior, override workflow, and cost. It avoids repeating schema details.

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 an 11-parameter mutation tool with full schema coverage and an output schema, the description covers the non-obvious operational aspects: defaults, overrides, exclusions, and costs. Nothing critical is missing for an agent to invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining the relationship between Image 1/Image 2 defaults and the identity/continuity override parameters, and by pointing to manga.list_panels for obtaining valid panel IDs. This helps agents understand how the parameters work together.

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

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

The description opens with 'Add the next panel', a specific verb and resource that clearly identifies the operation as extending an existing manga story. This differentiates it from siblings like manga.regenerate_panel (replacing an existing panel) and manga.create_story (starting a new story). The title 'Continue manga story' 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.

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

The description gives explicit usage guidance: do not send style_id, the default image slot behavior, and how to override via manga.list_panels plus identity/continuity fields. It also clarifies credit costs relative to create. It does not explicitly contrast with regenerate_panel, but the guidance for overriding and defaults is concrete enough for correct invocation.

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

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

Annotations indicate a non-readonly, non-idempotent operation. The description adds crucial behavior: style locking, default async behavior, credit costs, and the returned fields (image_url, story_id, panel_id). No contradiction with annotations; it enriches them.

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

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

The description is a single, dense sentence that front-loads the core purpose and required inputs, then covers async, credits, and next step. No wasted words; every phrase carries meaning.

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 tool with a rich schema and an output schema, the description covers all essential operational details: required params, cost model, async behavior, and the natural next step (continue_story). Nothing needed for correct invocation is missing.

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

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

Schema coverage is 100%, with detailed descriptions for each parameter (e.g., quality costs, style_id source, identity_image alias). The description adds only marginal context beyond the schema, so the baseline 3 is appropriate.

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

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

The description states a specific verb ('Start a new private manga') and resource (panel 1), clearly distinguishing it from siblings like continue_story. It also specifies required parameters and the flow, leaving no ambiguity about what the tool does.

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 states when to use: to create the first panel, and points to the alternative 'manga.continue_story' for subsequent panels. It also references list_styles for style_id, giving clear context for selection among siblings.

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

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

The annotations already declare readOnlyHint and idempotentHint, so the description adds valuable behavioral context: it explains the meaning of spendable credits, that weeklyCredits is display-only, and how ad/referral grants work. This goes beyond the safety profile and provides critical semantics about the data returned.

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 three sentences long, front-loaded with the primary action ('Return the API wallet') followed by essential details on credit semantics. Every sentence earns its place with no redundancy or fluff.

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 description fully explains the return value's semantics and the role of weeklyCredits, which is crucial for correct usage. It does not explicitly mention a common use case like checking credits before a purchase, but the output schema covers the response structure, and the description is sufficiently complete for a read-only tool with simple parameters.

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

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

The single parameter include_notes is fully documented in the schema (100% coverage), including its default behavior. The tool description does not add any additional parameter-specific information, so a baseline of 3 is appropriate since the schema already carries the semantic weight.

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's function: 'Return the API wallet' and explains the composition of spendable credits. It distinguishes from siblings like manga.buy_credits by focusing on retrieval rather than purchase, making the purpose unambiguous.

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

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

The description implies usage for checking available credits but does not explicitly state when to use this tool versus alternatives like manga.buy_credits. There is no direct mention of 'use this to check credits' or exclusions, leaving the agent to infer the appropriate context.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds meaningful behavioral context by disclosing the polling loop and terminal states (succeeded or failed), which is not visible from annotations alone. It does not mention timeout or rate-limit behavior, but those are less critical for a read-only poll.

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 pack the operation, trigger condition, polling loop, terminal statuses, and a recommendation to prefer async=false. Every phrase earns its place and is front-loaded with the 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?

With a single well-documented parameter, a provided output schema, and safety annotations, the description fully covers what an agent needs to invoke it correctly. It explains the source of job_id, when to poll, how long to poll, and even the preferred alternative.

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

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

Schema description coverage is 100%, so the schema already documents job_id with an example. The description reinforces that job_id comes from a previous generate result but does not add new syntax or formatting details beyond the schema, so the baseline 3 applies.

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

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

States a specific verb 'poll' and resource 'generation job', and identifies the exact producing tools (manga.create_story, manga.continue_story, manga.regenerate_panel) plus the async=true condition. This clearly distinguishes it from content-creation and billing siblings like manga.create_story or manga.buy_credits.

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 says when to use it: when async=true, and instructs to repeat until status is succeeded or failed. It also gives an exclusion by recommending 'Prefer async=false so you do not need this tool.' This is clear usage guidance, though it does not name a sibling alternative.

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

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

Annotations already communicate readOnly, idempotent, open-world, and non-destructive behavior. The description adds meaningful context beyond those hints: the 'you own' scoping and the ref_role semantics on the first panel, last distinct panel, and otherwise null. This is genuine behavioral detail that helps the agent interpret rows correctly.

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

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

The description is compact and well organized: an initial statement of what the tool returns, a practical usage instruction, and then the most important data nuance about ref_role. No filler or repeated annotation information is included.

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, single-parameter listing tool that already has an output schema and read-only/idempotent annotations, this description is complete. It tells the agent what it will get and why, and the workflow guidance removes the likely source of misuse. Nothing critical 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 input schema already fully documents the only parameter, story_id, with an explanation and example. The description does not add new parameter-level semantics beyond saying the panels belong to a story, so a baseline score of 3 is appropriate because the schema carries the load.

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

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

The description uses specific verbs and resources: it 'List[s] panels you own for a story', identifies the primary value returned (panel_id), and mentions the story context. It also distinguishes this tool from the sibling mutation tools by framing it as the lookup step before continue_story or regenerate_panel.

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 an explicit usage rule: use this tool to get panel_id values 'before changing Image 1 or Image 2 on manga.continue_story or manga.regenerate_panel.' This tells the agent both the task and the correct sequencing relative to two sibling tools, so there is no ambiguity about when it should be called.

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

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

The annotations already cover the safe read-only, idempotent, non-destructive profile, so the description's added 'newest first' ordering and the semantic that it lists owned stories carry useful extra information. It adds behavioral ordering context beyond the annotations without repeating them.

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

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

Two short sentences, no filler. The core action and ordering are front-loaded, and the when-to-use note is compactly integrated, followed by the parameter guidance.

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 is simple, has a single optional parameter, rich annotations that establish behavior, and an output schema. The description contains enough context about when and how to call it, including the concrete recovery scenario, for an agent to proceed safely.

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

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

Schema description coverage is 100%, and the description repeats the same limit details already provided in the schema. The description adds no new meaning beyond the input-schema, which is acceptable for a single, clearly documented optional parameter.

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

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

The description states the action and scope precisely: 'List stories you own, newest first.' It also clarifies the resource boundary from related tools by mentioning recovery after losing story_id, so an agent can distinguish it from manga.continue_story and manga.list_panels without opening schemas.

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 explicitly tells the agent when to call it: 'Call this when you lost story_id after context compaction so you can resume with manga.continue_story.' This provides clear context and names the continuation tool, though it does not explicitly enumerate when-not-to-use siblings.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior, so an agent knows this is a safe read. The description layers on the valuable addition that ids are 'live' (real-time) and that experimental/alias values are excluded, which affects result interpretation. The '24 canonical' count also sets accurate expectations. These details enrich—but don't fully transform—what annotations already convey, so not 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?

Three sentences deliver purpose, sequencing, exclusions, and filtering options with zero waste. The most critical information (what it lists) is front-loaded, and the sibling-tool reference is efficiently woven in. Every clause 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?

For a read-only list tool with 2 optional, fully-documented parameters, a present output schema, and complete safety annotations, this description covers all bases: what, when-to-call, exclusions, and how to filter. There is no missing information an agent would need to invoke it correctly.

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

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

Schema coverage is 100% with thorough type, enum, and description fields on both group and limit parameters. The description's 'Filter with group or limit when you only need one look' does add use-case framing beyond the schema, but the schema already carries the semantic weight. This aligns with the baseline-3 expectation when schema documentation is comprehensive.

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

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

The description opens with a specific verb and resource: 'List the 24 canonical Mangii art styles with live style ids.' This precisely scopes what the tool returns and is clearly distinct from its content-creation siblings. Mentioning 'Call this before manga.create_story' explicitly distinguishes it from a named sibling.

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 explicit when-to-use guidance: 'Call this before manga.create_story.' It also explains the exclusion of experimental and alias ids, setting expectations for output. It stops short of naming an alternative tool for when this one doesn't apply, but the sequencing mandate and filter hints provide solid directional context.

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

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

Annotations already declare readOnlyHint=false, so the agent knows it's a write operation. The description adds behavioral context: 'Style stays locked' and the credit cost, plus the image override semantics via continue_story. It does not explicitly state whether the panel is overwritten or a new version is created, but given the annotations cover mutation, this is acceptable.

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 filler: purpose first, then key constraints (style lock, image refs), then practical guidance (where to get IDs) and cost. Every sentence adds value and the structure is front-loaded with the main 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?

An output schema exists, so return values are covered. The description provides the critical operational details: style lock, image override behavior, ID source, and cost. It does not mention async behavior or idempotency, but those are in the schema. For a 12-parameter tool with a rich schema, this description is sufficiently 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 the description does not need to explain parameters. It adds a hint about image overrides (Image 1 / Image 2) which relates to parameters like identity_image and continuity_image, but this is not necessary since the schema already documents all fields with descriptions. Baseline 3 is appropriate.

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

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

The description states a specific action ('Redraw or edit one panel') with a clear resource, and distinguishes it from sibling tools by mentioning 'Style stays locked' and 'Same Image 1 / Image 2 ref overrides as manga.continue_story', which signals it is for panel-level regeneration rather than story continuation. The verb is clear and not a tautology.

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

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

It tells the agent where to get IDs ('Get ids from manga.list_panels') and notes that the image override behavior matches manga.continue_story, giving practical context. It does not explicitly contrast with all siblings, but it implies that for new panels one would use create_story and for continuation continue_story. It also mentions cost, which is useful for deciding when to use it.

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