Magnific

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

Annotations indicate idempotentHint=true and destructiveHint=false, but the description adds valuable context: it explains the token can be non-expiring if added to config, or session-only if pasted. It also clarifies the flow (browser login, copy token). This goes beyond annotations, though it doesn't mention any side effects like creating a session or storing state.

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 paragraph but packs a lot of information. It's front-loaded with the tool's purpose and then explains usage. Slightly dense but efficient; 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 the tool's simplicity (one optional param, no output schema), the description covers the essential flow: how to authenticate, the two modes, and the parameter usage. It could mention what the response looks like (e.g., success message) but that's minor given no output schema.

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

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

The schema has one optional parameter 'token' with no description (0% coverage). The description compensates by explaining the token parameter: it should be a JWT pasted by the user, and calling with no args returns the link. This adds meaning beyond the bare 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's purpose: to authenticate an IDE agent (like Cursor) with MCP.AI by logging in via browser and obtaining an access token. It distinguishes itself from siblings by being the only authentication tool among many content-generation tools.

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 explicit usage guidance: it explains two methods (permanent config-based token vs session-only token), when to call with no args to get the link, and when to call with the token. It also mentions the alternative of adding the token to the server config, which is a clear alternative path.

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=true, idempotentHint=true, and destructiveHint=false. The description adds useful behavioral context by explaining conditional output states: authenticated:true with empty pending[] when all providers connect, and connect_url when credentials are missing. This goes beyond the annotations without contradicting 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 three sentences with no wasted words. It front-loads the core purpose and immediately provides conditional behavior details, making it easy for an agent to parse quickly.

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 with zero parameters and no output schema, so the description carries the full burden of explaining the return value. It explains both success and missing-credentials cases, which is enough for an agent to know what to expect.

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 has zero parameters, so the schema provides no parameter information to compensate for. The description correctly focuses on output behavior instead, which is appropriate for a no-argument status-checking tool.

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 connection status and URLs, with a specific verb ('Returns') and resource ('connection status'). It distinguishes itself from sibling 'authenticate' by focusing on status inspection rather than performing authentication.

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: call this tool to check provider connection status and retrieve URLs when credentials are missing. However, it does not explicitly say when to use this instead of 'authenticate' or other sibling tools, nor does it provide any 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.

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context by noting 'No history,' which clarifies that past balance data is not accessible, and it specifies the exact response shape.

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 extremely compact and front-loaded. Every sentence earns its place: the purpose, the usage trigger, the return structure, and a key limitation ('No history') are all conveyed in just three short sentences with no redundancy.

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, parameterless read-only balance tool with strong annotations, the description is fully complete. It names the purpose, usage context, return fields, and an important limitation, all within the scope of what an agent needs 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?

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameters, and it adds meaningful semantic value by detailing the output fields (plan and credits) that the agent can expect.

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 clear, specific purpose: 'User plan + credits. Check before paid generations.' It names the resource (account balance) and the concrete return fields (plan.tier, credits.available, etc.), making it easily distinguishable from the many generation and creation sibling tools.

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 use this tool: 'Check before paid generations.' It does not mention alternative tools or exclusions, but given the unique account-balance role among siblings, this is a clear and sufficient usage cue.

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 signal non-read-only and non-idempotent behavior. The description adds useful context about fixed vs. configurable durations per model. However, it does not disclose whether generation is asynchronous, what the return value is, or what happens if durationSeconds is passed to a fixed-duration model.

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 dense sentences with front-loaded purpose and no filler. Every clause adds useful information about invocation or model behavior.

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 core invocation and model-specific duration rules, which is sufficient for basic use. But it lacks default model behavior, folderReference semantics, and any indication of return format or async behavior, and there is no output schema to fill those gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It explains prompt, model, durationSeconds, and instrumental, and adds meaningful duration constraints per model that go beyond the raw schema. However, it omits folderReference entirely, leaving one parameter 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?

The description opens with 'AI music generation', a specific verb+resource phrase that clearly distinguishes this tool from sibling audio_tts and other creation tools. It also names the supported providers (Google Lyria, ElevenLabs) and key parameters, 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?

Provides concrete model-selection guidance by stating duration constraints: Lyria/Lyria-3 fixed 30s, Lyria-3-Pro 30–180s, ElevenLabs 10–300s. It does not explicitly say 'use this instead of audio_tts', but the 'music generation' framing makes the intended use case clear.

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 provide no hints (all false), and the description adds no behavioral details beyond the obvious fact that it generates TTS audio. There is no mention of side effects, costs, permissions, rate limits, or what the tool returns. The description fails to disclose any non-obvious behavior, leaving the agent without important context.

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 and front-loaded with the core purpose. It uses three short sentences to convey the essential information, and every clause adds value. While it could be slightly more structured (e.g., grouping parameters), it is efficient and easy to parse.

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 complexity (12 parameters, no output schema, no annotation hints), the description is incomplete. It does not explain return values, parameter relationships, model selection criteria, or typical usage patterns beyond the voiceId prerequisite. This is insufficient for a tool with this many options.

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 12 parameters and 0% schema coverage, the description must compensate, but it only partially explains 'voiceId' and 'speakers' (single vs dual). It does not explain 'model', 'speed', 'stability', 'folderReference', or others. The mention of modes is helpful but insufficient for the full parameter set.

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 'TTS voiceover', which is a specific verb-noun pair. It further specifies single or dual-speaker modes and mentions ElevenLabs/Google as providers. This distinguishes it from sibling tools like audio_music_generate and audio_voices_list, making its purpose unmistakable.

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

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

The description gives explicit conditional guidance: 'No voiceId? Call audio_voices_show first (or audio_voices_list for agent-only lookup).' This informs the agent of the prerequisite step needed before invoking this tool. However, it does not provide general when-to-use/not-use alternatives compared to other tools, but the voice ID guidance is genuinely useful.

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 readOnly and idempotent, and the description adds that it returns raw text without UI and lean entries (no preview URLs). This clarifies the output structure and confirms no side effects. The description does not contradict the annotations and provides extra detail about the response format.

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 succinct, using two short sentences to convey the tool's purpose and parameter behavior. No redundant words or filler. It is appropriately structured for a tool with a single optional parameter.

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 simple schema (one optional string) and annotations that already cover safety, the description is sufficient. It provides context about the output format (raw text, no UI) and the filtering capability. It could mention typical use cases, but the information is adequate for a basic understanding.

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 'search' parameter is well explained: it filters by name, description, gender, or language. This adds meaningful semantics beyond the bare string type. However, it does not specify match behavior (e.g., substring vs exact) or case sensitivity, leaving some ambiguity.

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 indicates the tool lists a TTS voice catalog, implying a read operation. It distinguishes from other audio tools by focusing on voice listing, and the mention of 'raw TOON text' and 'lean entries' suggests a programmatic output format. However, the exact verb 'list' is implicit in 'catalog', so not maximally explicit.

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 use for retrieving available voices before TTS generation, but does not explicitly state when to use this tool versus alternatives. It contrasts with 'no UI' to hint at programmatic use, but lacks explicit guidance on scenarios or prerequisites. No mention of alternative tools or conditions.

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 indicate this is a non-read-only, non-destructive, non-idempotent operation. The description adds the 'user-owned creation' constraint, which is useful behavioral context, but it does not disclose prerequisites, permission requirements, or side effects beyond what annotations convey.

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, concise sentence that front-loads the core action and object. There is no filler or redundant phrasing.

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 4 parameters, no output schema, and zero schema description coverage, the description is too thin. It omits required parameter roles, reply behavior, folderReference meaning, and any expected response or error conditions, making it incomplete for reliable invocation.

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 0%, so the description must compensate for parameter meaning. It only hints at the reply concept ('or reply') and the target ('creation'), but does not explain folderReference, replyToCommentId, creationIdentifier, or text semantics. This is insufficient for a 4-parameter tool.

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 a specific verb ('Add') and resource ('comment or reply') and scopes it to 'user-owned creation', clearly distinguishing it from sibling tools like magnific_creations_like or magnific_creations_list. It fully identifies the tool's 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 clearly indicates when to use the tool: to add a comment or reply to a user-owned creation. It does not explicitly name alternatives or exclusions, but the context is unambiguous and no sibling tool competes for this behavior.

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

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

No annotations beyond basic hints; description mentions size limits (<=25MB images, <=200MB videos) which is useful, but does not disclose what happens on failure, whether it's a mutation of existing creations, or if there are any side effects. The bare 'convert' and 'finalize' imply mutation, but no detail on success/error behavior or partial failures.

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?

Description is brief and front-loaded with the critical 'Step 2 after PUT' context, then adds size limits. It could be more structured, but it's efficient for a simple tool.

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?

Tool has no output schema and few annotations, so description must carry more weight. It covers size constraints but leaves out parameter usage, error handling, and any post-conditions. For a finalization step, more detail on what 'convert' implies (e.g., does it delete temp files? does it return creation IDs?) 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 2 params with 0% description coverage; description does not explain the difference between 'path' and 'uploads' or how they relate. Agents cannot infer which parameter to use for what, especially given no required params and nested objects.

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 finalizes uploads after a previous request_upload step, converting temp paths to creations. It could be more explicit about the verb 'finalize' and the resource, but it does distinguish from sibling `request_upload`.

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 explicitly indicates this is 'Step 2 after PUT from creations_request_upload', providing clear sequencing context. It doesn't mention when not to use it, but the step-specific guidance is helpful.

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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is already covered. The description adds the specific URL fields and their approximate sizes, which is useful behavioral detail beyond the annotations. It does not mention pagination or error behavior, but with a single-parameter fetch, 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?

The description is one concise sentence that packs the essential information: resource, scope, and return data specifics. It is front-loaded with the core purpose and adds the key URL details without 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?

For a simple get-by-ID tool, the description is reasonably complete given the annotations and output schema (though none exists). It covers the primary return fields but could mention potential absence of data or error cases. With only one parameter and no output schema, the description meets the minimum bar but could add a bit more context about typical use flow.

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 0%, so the description must explain the parameter. It mentions the creationIdentifier implicitly by saying 'Single creation' but does not explicitly name the parameter or provide format/conventions. However, the schema property name is self-explanatory (creationIdentifier is a string), which mitigates the lack of description. The description adds the purpose but not extra semantics like required format or how to obtain the identifier.

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 identifies the tool as fetching a single creation's complete data, including the URLs for different resolutions. It specifies the exact resource (creations) and the scope (single item vs. list), distinguishing it from siblings like magnific_creations_list and magnific_creations_search.

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 use for retrieving detailed data for a single creation, but it does not explicitly state when to use this over list/search tools or mention any prerequisites. It lacks guidance on when not to use it, but the purpose is clear enough for an agent to infer the primary use case.

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 indicate this is a non-read-only, non-idempotent operation. The description adds the word 'toggle' and the reaction type, but does not explain side effects, whether a like can be removed, or what happens when `unlike` is true or false. It does not contradict annotations, but contributes minimal behavioral detail beyond 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 front-loaded sentence with no wasted words or extraneous detail. It is concise and scannable, though the brevity comes at the cost of missing semantic and 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?

For a three-parameter mutation with no output schema and no parameter descriptions, the description is not complete enough for reliable invocation. An agent cannot determine the required identifier semantics or the intended behavior of the `unlike` parameter.

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 0%, and the description does not explain `creationIdentifier`, `folderReference`, or `unlike`. A boolean named `unlike` is especially critical because the description says 'toggle' rather than specifying whether the parameter adds or removes the reaction.

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 a specific verb and resource: 'Toggle heart/favorite reaction on a user-owned creation.' This is enough to distinguish it from sibling tools like comment, move, or get/list. The phrase 'user-owned creation' is slightly ambiguous, so it does not earn a 5.

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

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

There is no guidance about when to use this tool versus alternatives, when the `unlike` parameter should be used, or what prerequisites or restrictions apply. The description merely restates the action rather than giving contextual or conditional usage guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds that the widget is filterable and media-scoped, but it does not disclose return behavior, pagination, or source semantics; this is acceptable but not rich beyond 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?

The description is two short sentences, front-loads the tool's purpose, and adds a clear usage directive with zero filler. Every phrase contributes meaningful selection information.

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 five parameters, no schema descriptions, and no output schema, the description is too thin to be functionally complete. It provides high-level purpose and sibling distinction but leaves important browse/filter semantics and expected results unexplained.

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 0%, and the description only repeats media types already present in the fileType enum. It does not explain the meaning or expected values of `from`, `query`, `reference`, or `toolNames`, so it fails to compensate for the schema gap.

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 identifies the tool as a filterable gallery widget for image/video/audio assets, and the tool name makes the listing purpose clear. It also distinguishes itself from `creations_search` by framing it as the browse-library option, though it lacks a direct imperative verb like 'list'.

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 says to use this tool instead of `creations_search` when the user wants to browse their library, providing both a concrete usage context and a named sibling alternative. This gives an agent clear selection guidance.

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

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

The description uses 'Move' which implies a destructive operation (removal from original location), but the annotation destructiveHint=false indicates the tool is not destructive. This direct contradiction misleads the agent about the tool's effect.

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 extremely concise, with four short sentences each adding a distinct piece of information: purpose, identifier source, abort condition, and ownership constraint. No unnecessary words or repetition.

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

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

For a simple two-parameter tool with no output schema, the description covers key aspects: action, input provenance, and constraints. It lacks details on success response but that's not critical for agent usage.

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 description adds some meaning by stating creationIdentifiers come from other specific tools and targetFolderReference must belong to the user. However, it doesn't explain the exact format or any additional details beyond what the schema already provides (param names and types).

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 'Move creations into targetFolderReference', specifying the verb (move), resource (creations), and destination. It also mentions identifier provenance from images_generate/creations_search, distinguishing it from sibling creation tools like get, search, or list.

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 provides usage context by specifying that identifiers must come from images_generate or creations_search, and states constraints: foreign identifiers cause an abort and target folder must belong to the user. While it doesn't explicitly list when not to use it, these conditions effectively guide proper usage.

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 description discloses that the actual upload happens outside the MCP, which clarifies the tool's limited scope. However, it does not mention any side effects, required permissions, or potential side effects (e.g., whether the URL is ephemeral or tied to a creation). The annotations provide no hints, so the description only partially covers behavioral transparency.

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, focused sentence with no redundancy. It conveys the essential information (step 1, presigned URL, external upload, next step) efficiently and is well-structured.

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 provides enough context for a basic understanding, especially by mentioning the dependent next step. However, it does not describe the return value (the presigned URL format or count), nor does it address error handling or edge cases. Given the lack of an output schema, it is not fully complete but acceptable for a simple step.

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 description does not explain the 'count' or 'mimeType' parameters. It only hints at 'URL(s)' implying count might be the number of files, but the required 'mimeType' is left undefined. The schema provides no descriptions either, leaving users to infer parameter meanings.

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: obtaining presigned PUT URLs for uploading files, and it identifies the tool as the first step in a two-step process. It uses specific verb ('get') and resource ('presigned PUT URL(s)'), 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 provides usage context by indicating this is for local/user files and explicitly mentions the sequential flow (upload externally, then call creations_finalize_upload). It implies when to use this tool, though it does not explicitly contrast with alternatives or mention 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.

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

Annotations indicate read-only, non-destructive, idempotent behavior. Description mentions output as raw TOON text, which aligns. Does not detail errors or side effects, but annotations cover safety, so transparency is adequate.

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?

Concise two-sentence description with no fluff. Information is directly relevant and well-structured.

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 core usage and defaults but lacks details on return format (though no output schema) and does not elaborate on all parameters or potential errors. Sufficient for basic use but not fully comprehensive.

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 0% description coverage for 8 parameters. Description mentions only 'from', 'reference', and 'page' (in defaults), leaving 'query', 'fileType', 'toolNames', 'folderReference', and 'excludeToolNames' unexplained. Significant gap in parameter guidance.

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 the tool searches user creations and returns raw TOON text. Also distinguishes from creations_get for single id, making its purpose specific.

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 an alternative (creations_get for one id) and describes key requirements like 'reference required with from=folder/project-root' and defaults for page. Lacks explicit exclusions for other search tools but overall gives useful usage 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?

The description discloses that the tool mutates state by importing the host-attached file as a creation and returns an identifier for subsequent image tool calls. However, it does not detail side effects (e.g., whether the original file is consumed, whether the creation is persisted) or any prerequisites/auth needs. The annotations already provide readOnlyHint=false and destructiveHint=false, so the description adds some but not rich behavioral context, warranting a mid score.

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 and every sentence adds value: the action, the usage condition, and the alternative. There is no redundant content, and the structure front-loads the core behavior.

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 single-parameter tool with no output schema, the description covers the main action, the triggering scenario, the alternative for URLs, and the result's follow-up use. It is slightly incomplete in not describing the exact return shape or any limitations (e.g., accepted file types) and it references the sibling tool with a slightly different name (`creations_upload_image`). Overall it is sufficiently complete for an agent to select and begin using 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?

With schema description coverage at 0%, the description carries the burden. It tells the agent that the `file` parameter represents a user-attached host file (e.g., a ChatGPT upload), which is valuable context, and implicitly distinguishes it from a URL. However, it does not clarify the roles of the nested `file_id`/`download_url` subfields, so the semantics are only partially explained.

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 a specific verb ('Import') with a clear resource ('a file the user attached... as a creation') and states the downstream purpose ('use the returned identifier in image tools'). It also names the alternative for public URLs, which helps distinguish it from the sibling `magnific_creations_upload_image`. Overall it clearly identifies what the tool does and how it differs from related tools.

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 says 'Use this instead of asking for a URL when the user already uploaded a local file', which defines the trigger condition. It also provides an exclusion: 'For a public URL use `creations_upload_image`'. This is exactly the kind of when-to-use vs alternative guidance expected.

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 indicate a write operation (readOnlyHint=false), and the description adds useful context that it is a one-step flow limited to public URLs. It does not disclose broader side effects, idempotency, or failure behavior, but for such a small upload action the added context 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, front-loaded action, and every phrase earns its place. The alternative-flow pointer is important and compact.

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

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

For a one-parameter tool without an output schema, the description conveys the primary usage decision (public URL vs local file) and points to the alternate path. It stops short of describing return values or post-upload effects, but the tool's simplicity keeps the gap small.

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 `url` parameter is only typed as a string in the schema with 0% description coverage. The tool description supplies the key meaning that this is a public image URL, but it does not detail format restrictions, access requirements, or how the URL is consumed.

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: it uploads a public image URL in one step. It also explicitly distinguishes this tool from the local-file upload flow by naming the sibling tools `creations_request_upload` and `creations_finalize_upload`, making its purpose clear relative to 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?

The description clearly states when to use this tool (for a public image URL) and provides an explicit alternative for local/user files (`creations_request_upload` then `creations_finalize_upload`). This is direct when-to-use versus 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.

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds valuable behavioral context beyond annotations: long-polling mechanics, the 1..8 batch limit, timeout default/max, and the poll_after_seconds retry hint.

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 deliver the core behavior, limits, timeout semantics, and retry guidance with no filler. Key information is front-loaded with the action verb.

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 polling tool with good annotations and only two parameters, the description covers purpose, limits, timeout, and follow-up calls. The absence of an output schema means the description could ideally clarify what 'terminal' looks like in the response, but this is a relatively minor gap.

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 must clarify the parameters. It does so by explaining the identifiers represent creations and that up to 8 can be polled, and by defining timeoutSeconds default and maximum. It does not explicitly label 'identifiers' as creation IDs, but the meaning is clear from context.

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 explicitly states the action ('Long-poll'), the resource ('creations'), the batch scope ('1..8'), and the completion condition ('until terminal or timeoutSeconds'). This clearly distinguishes it from sibling tools like magnific_creations_get or magnific_creations_list.

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 the intended usage: call after starting creations to wait until they reach a terminal state, then use poll_after_seconds for follow-up calls. It does not explicitly name alternatives or state when not to use this tool, but the polling semantics are clear.

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 provide only generic hints (readOnlyHint=false, destructiveHint=false), so the description carries most of the behavioral burden. It adds the useful context of extracting layers from a flat image into a design, but does not disclose whether the original is preserved, whether an async creation is triggered, or what side effects occur beyond the implied generation.

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 one concise, front-loaded sentence, but it is under-specified rather than efficiently complete. It earns its place but omits critical operational and parameter information.

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 four parameters, no output schema, and weak annotations, a single sentence is insufficient. The required creationIdentifier is unexplained, and there is no information about return values, asynchronous behavior, or how the extraction process is initiated or completed.

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 0%, and the description does not explain any of the four parameters. The agent is left unable to know the meaning of required 'creationIdentifier' or the optional 'name', 'numLayers', and 'vectorize'.

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 a specific verb ('Extract') and clearly identifies both the source ('flat image') and the result ('editable layers' into a 'Pikaso design'). This makes the tool's function distinct from siblings like magnific_design_auto_resize or magnific_images_to_svg.

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 is given about when to use this tool versus alternatives. There are no usage scenarios, prerequisites, or exclusionary statements, leaving the agent without context for selecting it among the many 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?

The description communicates that this tool creates resized pages from an image and implies direct execution when target formats are known. It adds some context beyond the annotations, but it does not disclose what kind of resources are created, whether any existing designs or images are affected, or how repeated calls behave. The annotations already mark it as non-read-only and non-idempotent, so the description is not contradictory but also 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.

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

The description is two concise sentences, front-loads the primary purpose, and includes a direct conditional usage note. There is no fluff, and 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?

The description is adequate for choosing between this tool and the show alternative, but as a 7-parameter creation tool with no output schema and no parameter descriptions, it leaves significant gaps. An agent can understand when to call it but would struggle to infer correct values for the optional parameters or predict what the return response looks like.

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 0%, so the description must compensate for the seven parameters. It gives meaningful hints only for `creationIdentifier` ('from an image') and `aspectRatios` ('ratios/social formats'). Parameters such as `numLayers`, `textLayers`, `imageLayers`, `multipage`, and `name` are left entirely unexplained.

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 action ('Create resized design pages from an image') and the core resource being produced. It also distinguishes itself from the suggested informational alternative `design_auto_resize_show`, making the tool's purpose easy to identify among the large sibling set.

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

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

The description explicitly says when to use this tool ('when ratios/social formats are known') and what to do otherwise ('otherwise show design_auto_resize_show'). This is a clean when/when-not/alternative instruction, fully satisfying the dimension.

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=true and destructiveHint=false, so safety is covered. Description adds value by explaining output format (raw TOON text) and normalized fields, but doesn't disclose potential errors or exact response structure beyond that.

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 extremely concise—two sentences, front-loaded with the core purpose, and adds contextual detail without fluff. It's optimally structured for quick agent consumption.

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 a single parameter and no output schema, the description explains the output format and sequencing ('Call before flows_run'), but fails to explain what 'identifier' relates to. With only one parameter, this omission leaves the tool ambiguous for agents, making it incomplete.

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 description completely omits any explanation of the 'identifier' parameter. With 0% schema coverage, the description was expected to clarify what identifier refers to (e.g., flow ID), but it doesn't mention it at all. This is a critical gap for a single-parameter tool.

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: returning raw TOON text for a flow's input/output spec, with specific fields mentioned. It distinguishes itself by explicitly instructing to call before flows_run, which differentiates it from other flow tools like flows_list.

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 clearly states when to use it ('Call before flows_run'), providing a direct usage context. However, it does not mention when not to use it or alternatives (e.g., flows_list for listing flows), so it lacks explicit exclusions.

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

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

Annotations already establish readOnly, idempotent, and non-destructive behavior. The description adds useful context about output format ('raw TOON text, no UI', 'lean entries without preview URLs'). It does not discuss pagination or auth, but the annotation coverage lowers the burden.

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 short sentences, each with a distinct job: output format, content leanness, and alternative tool guidance. No filler or redundancy.

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 tells the agent what the response looks like and which sibling tools to use for other needs, but it omits parameter usage, pagination behavior, and response field details. With no output schema and low schema description coverage, this leaves gaps for a 4-parameter 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?

None of the four parameters (page, query, perPage, ownership) are described in the description. With 0% schema description coverage, the description needed to compensate but only addresses output format, leaving the agent to infer parameter behavior from names alone.

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 that this tool exposes the flows catalog as raw TOON text with lean entries and no UI, and it distinguishes itself from flows_show and flows_get for inline picking and single-flow specs. It lacks an explicit verb like 'lists,' but the tool name and the contrast with sibling tools make the purpose clear.

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 use alternatives: 'For an inline picker use flows_show; for a single flow input/output spec use flows_get.' It also warns that the output is raw TOON text with no UI and no preview URLs, which helps the agent avoid using it for display-heavy tasks.

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 mark this as non-read-only and non-idempotent, and the description adds useful context that running a flow is asynchronous, returning a workflowRunIdentifier that requires flows_wait and creations_show. However, it does not disclose potential side effects such as credit consumption, external generation, 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?

Three tight sentences convey the core action, prerequisites, input mapping, and expected follow-up sequence. Every clause adds value and the front-loaded 'Run flow' makes the purpose immediately clear.

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 lack of output schema and sparse annotations, the description outlines the full invocation chain: flows_get → run → flows_wait → creations_show. It covers the essential workflow lifecycle, though it omits auth requirements, error handling, and cost implications that could be relevant for a flow-execution tool.

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

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

Schema coverage is 0%, so the description carries the burden. It helpfully explains the shape of inputs as {inputId: value} and gives concrete source examples, but it does not explicitly explain the identifier parameter beyond the implicit context that flows_get should be called first. This is partial but not complete compensation.

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?

Starts with a clear, specific verb and resource: 'Run flow.' It distinguishes itself from sibling tools like flows_get, flows_list, and flows_wait by describing its role as initiating execution and returning a workflowRunIdentifier that feeds into flows_wait and then creations_show.

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 instructs to call flows_get first for input specs, and clarifies where input values come from (creations_list, audio_voices_show). It provides clear context for when to invoke this tool in a workflow, though it does not state explicit exclusions or alternatives beyond the implied prerequisite chain.

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 mark the tool as read-only, idempotent, and non-destructive. The description adds behavioral context beyond annotations by explaining the long-polling semantics, terminal results, and the `poll_after_seconds` behavior when the run is still in progress. It does not contradict any annotation; it only omits edge-case behavior such as timeout handling.

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 extremely concise: two short sentences that lead with the main action, then provide terminal/in-progress behavior. Every word adds useful information and no filler or repeated schema content is present.

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?

Despite having no output schema, the description conveys the most critical behavioral contract: terminal responses contain one entry per output creation with a real identifier for `creations_show`, and in-progress responses provide `poll_after_seconds`. It is mostly complete for a polling tool, though it could mention timeout/error outcomes; given the read-only annotations, this level 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 description coverage is 0%, and the description does not explicitly explain either `workflowRunIdentifier` or `timeoutSeconds`. The only indirect hint is 'Long-poll a `flows_run`,' which suggests the subject is a flow run identifier, but the agent gets no guidance on how `timeoutSeconds` behaves or how it interacts with polling. This leaves the parameter-heavy workload under-documented.

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 purpose with a specific verb and resource: 'Long-poll a `flows_run`.' It also clarifies the expected outcome by contrasting 'Terminal' behavior (one entry per output creation with real identifiers for `creations_show`) and 'In-progress' behavior (`poll_after_seconds`), which differentiates it from sibling tools like `magnific_flows_get` or `magnific_creations_wait`.

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 a clear context for when to use the tool: you should call it to long-poll a flow run and handle terminal versus in-progress states. However, it does not explicitly name alternatives or state when not to use it (e.g., 'instead of `magnific_flows_get`'), so it lacks full when/when-not guidance.

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

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

The annotations already declare readOnlyHint=false and destructiveHint=false, so creation is understood. The description adds non-obvious behavioral defaults: omitting parentReference means workspace root, and the default type changes from project at root to folder when nested. It does not mention possible side effects or return values, but the core behavior is clearly disclosed.

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 only two sentences and each sentence adds meaningful information. There is no wasted wording, and the most important purpose is front-loaded.

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 create tool with three scalar parameters and no output schema, the description covers essential placement and type-default behavior. A full list of allowed type values or explicit creation-response expectations would improve completeness, but the description is not misleading or materially incomplete.

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 0%, so the description must compensate. It explains the meaningful semantics of parentReference (workspace root when absent) and type (project at root, folder when nested). The required 'name' parameter is left implicit, and possible type values are not enumerated, but the most non-trivial parameter behavior is surfaced.

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 begins with a specific verb and resource ('Create folder/project') and gives useful placement context about workspace root and nested behavior. It clearly distinguishes from the folder CRUD siblings, though it does not explicitly differentiate from other creation tools like spaces_create or library_create.

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 the tool by naming 'folder/project', and it provides context about root versus nested creation via parentReference. However, it does not explicitly state when this tool should be chosen over alternatives or describe exclusions.

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

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

The description says the tool moves a folder and its files to trash, which is a destructive/state-changing operation, yet the annotations declare destructiveHint=false. This is an annotation contradiction and misleads the agent about the tool's safety profile.

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 one concise, front-loaded sentence that conveys the core action and scope without 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?

For a simple single-parameter tool this is very brief, but it omits essential context: what the caller should pass as reference, what happens to the trashed items or whether this is recoverable, and any return/confirmation behavior. The contradictory destructiveHint annotation further undermines completeness.

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 0%, so the description must compensate for the undocumented 'reference' parameter. It only implies that reference identifies the folder to be removed, but does not explain the reference format, required scope, or how it is used.

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 a specific verb ('Move') and clearly identifies the resource ('a folder and its files') and result ('to trash'). It is distinct from sibling folder operations like create, get, list, and rename.

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

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

There is no guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites mentioned. The description only states the action, leaving the agent to infer suitability from the tool name.

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=true, idempotentHint=true, so safety is covered. The description adds the error behavior for 'foreign refs' and the dependency on being used before creations_search, which goes beyond annotations. It does not describe return format, but for a simple read tool that's 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 short sentences, front-loaded with the action and key usage. Every word adds value; no 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?

With one param, no output schema, and strong annotations, the description covers the essential usage and error condition. It doesn't elaborate on return content, but the term 'metadata' gives a general expectation. The usage note adds important context for sequencing.

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 only 'reference' with no description (0% coverage). The description says 'by reference' and implies it's a folder reference, giving meaning to the parameter. It could be more explicit about the format (ID vs path), but for a single straightforward param, this is adequate.

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 it fetches folder metadata by reference, which is a specific verb+resource action. It also differentiates from sibling tools like magnific_folders_list by focusing on a single reference, and mentions a prerequisite usage before creations_search.

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 explicitly says 'Use before creations_search (from=folder)', giving a concrete usage context. It also mentions that foreign refs error, which implies a constraint. However, it doesn't explicitly state alternatives or when not to use it, but the context is sufficient for most cases.

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=true, idempotentHint=true, destructiveHint=false, so the tool's safety profile is covered. The description adds that it returns raw TOON text, which is useful, but doesn't disclose pagination behavior or potential large response sizes. No contradiction.

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 and front-loaded with the core purpose. It uses a compact format to explain parameters, but the sentence about refs is somewhat cryptic and could be clearer. Still, it's efficient with no 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 tool has only 3 optional parameters and no output schema, so the description is somewhat adequate. However, with no output schema, it should describe the return value format more thoroughly (e.g., structure of the TOON text), which it only mentions as 'raw TOON text'. Additionally, the page parameter is left undefined. Given the tool's moderate complexity, it's incomplete but not severely lacking.

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 0%, so the description must compensate for parameter meaning. It explains the effect of each parameter (onlyProjects, parentReference) decently, but page parameter is not mentioned at all. This is a significant gap since the description doesn't explain pagination.

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 folders/projects with specific filtering options, distinguishing it from other folder-related tools like magnific_folders_get, create, delete, rename. It also mentions the output format (raw TOON text), which adds specificity.

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 usage context: no params for top level, onlyProjects for projects, parentReference for children. It also notes that refs work with creations/folder tools, hinting at integration with other tools. However, it doesn't explicitly state when not to use it or compare with sibling folder 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?

The description adds no behavioral context beyond what annotations already indicate. It does not describe side effects (e.g., impact on child items), permission requirements, or return behavior. Annotations (readOnlyHint=false, destructiveHint=false) imply mutation but non-destructive, yet the description provides no additional detail to enrich understanding.

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 extremely concise, with no wasted words, and the key verb and resource are front-loaded. However, it is so brief that it borders on under-specification, though this is still efficient for a simple operation.

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 has two required parameters, no output schema, and annotations are minimal, the description is incomplete. It fails to mention what the function returns (e.g., the renamed folder object or success status), any constraints on names, or potential errors. This is insufficient for an agent to fully anticipate behavior.

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 must compensate. It mentions 'by `reference`', implying that 'reference' identifies the folder to rename, but does not explicitly clarify the role of 'name' (likely the new name). This partial explanation leaves one parameter's semantics ambiguous.

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 action: 'Rename a folder' with the subject being a folder and the method being by reference. It unambiguously identifies the resource and operation, distinguishing it from sibling tools like create, delete, get, and list.

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 is provided on when to use this tool versus alternatives. The description does not mention prerequisites, exclusions, or when a rename might be preferred over other folder operations, leaving the agent without contextual decision-making help.

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 give no hints for read-only, idempotent, or destructive behavior, but they set destructiveHint=false. The description mentions defaults for rotate, vertical, and closeup, which adds some context, but it does not disclose potential side effects like modifying the original creation, whether changes are reversible, or if any assets are destroyed. This is a significant gap since the tool likely mutates the creation.

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 very short and front-loaded with the main purpose in the first sentence. The second sentence lists defaults efficiently. However, given the lack of parameter details, the brevity might be too extreme, but for a two-sentence description it is acceptable.

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 has 5 parameters, no output schema, and no annotations, the description is inadequate. It does not explain the meaning of parameters, expected input (e.g., creationIdentifier presumably identifies a creation), or return values. It is not complete enough for an agent to use the tool without further assumptions.

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 0%, with 5 parameters. The description only explains the default values for rotate, vertical, and closeup, but does not explain what these parameters mean, their units, ranges, or how they affect the output. It fails to compensate for the absent 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 states the action (reframe camera around subject) and implies the resource (images). It is clear enough to distinguish from siblings like magnific_images_crop, which also modify images but in a different way. However, it lacks explicit reference to the 'images' resource.

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 no guidance on when to use this tool versus alternatives (e.g., when to rotate vs. crop). It implies usage for changing camera angle but does not state when not to use or mention any prerequisites (e.g., needing an existing creation).

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 description conveys the core behavior of center-cropping, but does not disclose whether the crop overwrites the original, creates a new artifact, or requires special permissions. Annotations are all false hints and do not provide this side-effect context, though there is no contradiction with the description.

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, front-loaded, and easy to scan. However, the ratio list repeats the schema enum and the 'Pixels:' phrasing is cryptic, so not every segment adds maximal clarity.

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

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

With no output schema and no parameter descriptions, the tool description is thin for reliable invocation. It omits the roles of `creationIdentifier` and `folderReference` as well as any post-crop behavior, so it is stronger for tool selection than for correct parameter construction.

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?

Only `aspectRatio` receives semantic context via 'Center-crop to `aspectRatio`', and the listed ratios merely duplicate the schema enum. The required `creationIdentifier` and optional `folderReference` are completely unexplained, leaving 0% schema description coverage uncompensated.

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 opens with 'Center-crop to `aspectRatio`', a specific verb plus resource and outcome. It also differentiates from sibling tools by explicitly naming `images_resize` and `images_upscale`.

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 phrase 'Pixels: `images_resize`. AI upscale: `images_upscale`.' points to alternative tools for non-crop operations, giving useful selection context. It is somewhat telegraphic, but the intended when-to-use distinction is clear enough.

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 only indicate non-readOnly, non-idempotent, non-destructive. The description adds defaults (mode=auto, ratio=1:1, count<=8) and a post-generation requirement, but doesn't disclose what the tool returns, side effects beyond Generation, or whether it's synchronous/asynchronous. It doesn't contradict annotations, but it could provide more 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.

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

The description is concise and front-loaded with the core purpose. It packs in essential constraints and defaults without unnecessary fluff. The structure is logical: purpose, refs behavior, defaults, and a clear UI-client mandate.

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 8 parameters, no output schema, and minimal annotations, the description leaves many gaps: no return format, error behavior, or detailed parameter semantics. It also relies on external references (field docs, images_models_list) for critical details, making it incomplete for an agent to use effectively without additional lookups.

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 0%, so the description must compensate for eight parameters. It mentions references, mode, ratio, count, and resolution/quality but doesn't explain their meaning, format, or interplay. For instance, 'mode' and 'count' are not described at all beyond defaults. The pointer to images_models_list is helpful but not self-contained.

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 'Generate/edit images' and distinguishes between text-to-image (no references) and image editing (with references). It also provides specific constraints (max 12 refs, defaults) that differentiate it from sibling tools like generate_svg or variations.

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 clear usage context: when no references are provided, it's TTI; it lists defaults and points to images_models_list for resolution/quality. It also includes a specific mandatory post-action (call creations_show) for UI clients. However, it doesn't explicitly contrast with alternatives like variations or editing tools beyond the basic refs distinction.

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 declare readOnlyHint=false and destructiveHint=false, but they do not specify side effects (e.g., cost, creation of a resource) which are likely for a generation tool. The description adds the model name (Recraft v4 Pro Vector) and default aspect ratio, which is extra context, but doesn't disclose typical behaviors like asynchronous generation or storage location. Given annotations are present, the bar is lower, but the description could add more on what happens after generation.

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 with critical information packed efficiently: purpose, model, sibling references, and default parameter. No redundancy or 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 3 parameters with zero schema description coverage, the description should elaborate on each parameter, but it only covers aspectRatio. Also, no output schema exists, yet the description doesn't mention what the tool returns (e.g., a creation ID or SVG URL). For a generation tool, this is incomplete; however, the tool name and context from siblings (like `creations_wait`) may imply asynchronous behavior, but that is not specified.

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 0%, so the description must compensate for parameter meaning, but it only mentions `aspectRatio` default (1:1) and does not explain `prompt` or `folderReference` at all. While the parameter names are self-explanatory, the description adds minimal value beyond the schema. With zero coverage, this is a gap, but the enums for aspectRatio provide some implicit guidance.

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 'Text-to-SVG (Recraft v4 Pro Vector)' which specifies the verb (generate SVG) and resource (from text prompt), and distinguishes it from related siblings by naming `images_generate` for raster generation and `images_to_svg` for tracing existing rasters. This is specific and 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 provides clear differentiation from sibling tools: it explicitly says to use `images_generate` for raster and `images_to_svg` for tracing existing raster. However, it does not mention when not to use this tool or alternative contexts beyond those two alternatives, but the exclusions are direct and helpful.

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, so the safety profile is covered. The description adds little beyond that—it only mentions search filtering and the output format 'lean TOON text,' which is vague and unexplained. No additional context about output structure, pagination, or latencies is provided. This does not contradict annotations, but adds minimal behavioral value.

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, compact sentence that gets straight to the point. It contains no filler, is front-loaded, and communicates the essential information efficiently. It is appropriately concise for a simple listing tool.

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 (0 required params, no output schema, annotations covering safety), the description is mostly adequate. However, it leaves `onlyRecommended` unexplained, and the term 'TOON text' is ambiguous without further context. The description could be more complete by detailing what the output looks like or what 'lean TOON text' means, but for basic invocation, it may suffice.

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 schema has 0% description coverage, so the description must compensate. It clarifies the `search` parameter by stating it filters by name, slug, description, or tags, adding real semantic value. However, `onlyRecommended` is not explained at all—its meaning is only inferable from the name. This partial explanation is helpful 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?

The description clearly states the tool lists TTI (text-to-image) models, using a specific verb and resource. The name itself is explicit about the domain (images) and action (list), and it distinguishes from sibling tools like magnific_video_models_list and magnific_audio_voices_list. The only minor ambiguity is the phrase 'lean TOON text,' but it doesn't obscure the core 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 provides no explicit guidance on when to use this tool over alternatives. It implies you use it to list TTI models, but there are no exclusions or alternative references. The sibling context shows many similar list tools, so some guidance would help, but the name and purpose are clear enough for basic selection.

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 provide all-false hints, so the description carries the full behavioral burden, but it only lists input constraints. It does not disclose whether the tool creates a new image, mutates an existing one, is asynchronous, requires permissions, or produces any other side effects.

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 very concise: three short sentences, front-loaded with the core operation, and every word adds value. There is no padding or repetition.

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 that output schema is absent, annotations do not describe behavior, and several parameters are undocumented by the description, a 5-parameter relight tool is not fully specified. The description covers the main light configuration well but lacks the broader contextual details an agent needs for safe and complete invocation.

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 coverage, the description adds useful semantics by specifying 1-4 lights, neutral/gel types, intensity 1-10, and gel hex color. However, it leaves top-level parameters like numImages, resolution, folderReference, and creationIdentifier unexplained, and 'azimuth/elevation enums' is ambiguous since the schema defines them as numbers.

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 identifies the operation as 'AI relight' and describes the specific lighting configurations it supports. This distinguishes it from sibling image tools such as resize, crop, and upscale.

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 is implied that this tool is for relighting an image, but the description does not explicitly state when to use it over alternatives or when it is not appropriate. There is no mention of exclusion criteria or comparisons to other image modification 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 provide only false hints (readOnly, destructive, idempotent) which offer little guidance. The description adds the output format (transparent PNG) and implies a mutation (cut-out) but does not disclose side effects like whether the original is altered, async behavior, or any rate limits. Some value is added, but major behavioral aspects remain uncovered, so a mid score is appropriate.

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 exceptionally concise: two sentences with the primary function first and alternatives listed in backticks. Every word contributes meaning; no filler or redundancy. It is front-loaded and structured for quick scanning.

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 2 required-or-optional parameters and no output schema, the description covers the core function and alternatives but omits parameter semantics and any prerequisites (e.g., authentication, required format of creationIdentifier). Given the low complexity, it is not fully complete but not disastrously lacking, so a 3 is fair.

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 0% for the two parameters, and the description does not explain `creationIdentifier` or `folderReference` at all. Without any parameter explanation, the agent cannot infer what to pass in. The description must compensate for the lack of schema descriptions but fails to, thus a score of 1.

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: 'Cut-out subject on transparent PNG' – a specific verb-resource pair (remove background to produce transparent output). It also distinguishes from alternatives by naming `images_color_background` and `images_generate` for different background treatments, so siblings are differentiated.

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?

Explicit when-to-use guidance: it says to use this tool for transparent PNG cutouts, and points to `images_color_background` for color backgrounds and `images_generate` with a prompt for AI scenes. This directly tells the agent when not to use this tool, making the usage context unambiguous.

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 provide little safety context (readOnlyHint=false, destructiveHint=false), so the description carries the burden. It adds valuable behavioral details: no AI, exact-pixel resizing, dimensions snapping to multiples of 8, and center-crop behavior on aspect mismatch. It does not mention persistence or return format, but the core behavior is disclosed.

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 front-loaded with the primary behavior, then immediately gives alternatives and key constraints. Every sentence adds useful information without repetition.

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 captures the core operation, sibling differentiation, and important dimension behavior, but it is incomplete for a tool with four parameters, zero schema descriptions, and no output schema. The required creationIdentifier parameter is opaque, and the agent gets no guidance on what it identifies or whether folderReference 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 description coverage is 0%, so the description must compensate. It gives meaningful semantics for width and height ('exact pixels', 'snap to multiples of 8', 'center-crop'), but the required creationIdentifier parameter and the optional folderReference parameter are not explained. This is a meaningful gap for correct invocation.

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 this resizes to exact pixels with no AI, references the images resource, and explicitly distinguishes itself from images_upscale and images_crop siblings. It is specific about what the tool does and how it differs from closely related operations.

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 direct alternatives: use images_upscale for real detail upscaling and images_crop for aspect adjustments. This explicitly tells the agent when to choose this tool versus its 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 description adds behavior beyond the annotations by explaining that faithful preserves identity, creative reinterprets, and flexible uses presets, and by listing default settings. It does not describe the overall output, side effects, or how the referenced creation is used.

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 short and front-loaded: the core purpose appears first, followed by mode semantics and defaults. Every sentence earns its place, with no redundant or filler content.

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 7 parameters, no output schema, and sparse annotations, the description provides only a high-level purpose and mode hints. It does not explain the return object, important parameter semantics, or the required `creationIdentifier` relationship, leaving significant gaps for an agent to infer.

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 0%, and the description only clarifies the version enum and the default values for sharpen and smartGrain. It leaves optimizedFor, skinDetail, folderReference, and creationIdentifier mostly unexplained, so most parameter semantics are not adequately covered.

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 identifies the tool as an AI skin enhancer and explains what each version mode does: faithful preserves identity, creative reinterprets, and flexible uses presets. This goes beyond the tool name, though it does not explicitly state the action as 'enhances the skin of a specified image.'

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 the tool by naming it a skin enhancer and gives mode-selection guidance through the faithful/creative/flexible meanings. However, it does not compare this tool to sibling image tools or state 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.

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

No annotations are provided (all false), and the description does not mention side effects, permissions, whether it modifies the original creation, or any behavioral details. The description only states the action without transparency.

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 very short but the second sentence is cryptic and could mislead. It could be clearer without being verbose, so it is acceptable but not excellent.

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 does not mention the output format (SVG), what a 'raster creation' is, or any prerequisites. It lacks context about how this tool fits into the workflow, making it incomplete.

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 schema has no descriptions for folderReference or creationIdentifier, and the tool description does not explain them at all. There is zero information about what these parameters mean, so the description fails to compensate.

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 gives a verb 'trace' and target 'SVG', but the second sentence referencing a sibling tool mixes two actions and creates ambiguity about whether it converts an existing raster or generates a new vector. It is not fully clear.

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 mentions using `images_generate_svg` for new vector from prompt, which helps differentiate from this tracing tool. However, it does not explicitly state when to use this tool versus other alternatives; it only implies the distinction.

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 are all false, so they don't convey much. The description adds 'premium' and 'AI' context, implying a paid AI service, and states 'Default scale=2' which is a behavioral default. However, it does not disclose whether the operation is synchronous, if it modifies the original, or what output is produced. This is adequate 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?

The description is extremely concise: a single sentence with key information front-loaded. It states the main purpose, alternatives, and default in under 20 words. No fluff, every word 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?

Given the tool has no output schema and no annotation guidance, the description should at least hint at outcome or side effects. It mentions 'premium' suggesting cost, and alternatives for other operations, but it does not describe what the tool returns (e.g., a new creation ID) or whether it modifies existing images. For a simple 3-parameter tool, this might be sufficient, but the lack of output/behavior details leaves gaps.

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

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

Schema description coverage is 0%, so the description must illuminate the parameters. It mentions '2x/4x' aligning with the scale enum and 'Default scale=2' which clarifies the scale parameter's default. However, it provides no explanation for creationIdentifier (though self-evident) or folderReference, leaving these ambiguous, especially folderReference which is not obvious. The description only partially 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 the tool's function: 'AI upscale 2x/4x' with specific scale options. It distinguishes from siblings by explicitly pointing to alternatives for exact pixel resizing (images_resize) and aspect ratio changes (images_crop), making the tool's unique purpose unmistakable.

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

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

The description provides explicit usage guidance by comparing with alternative tools: 'Exact pixels: images_resize. Aspect: images_crop.' This tells the agent when to choose this tool over others. It also notes the default scale, giving a concrete parameter default. This is strong guidance for selection.

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

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

With all annotation hints false, the description carries the sole burden of behavioral disclosure. It reveals default grid size and resolution but nothing about side effects (e.g., credit usage, asynchronous generation), prerequisites (like requiring a creationIdentifier), or limitations of the varying modes. This minimal detail is insufficient for a generation 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 a single well-structured sentence that front-loads the core purpose and then packs the optional mode list and defaults without wasted words. Every element adds value, achieving high information density.

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 11 parameters, 0% schema coverage, no output schema, and no helpful annotations, yet the description is just one sentence. It omits essential context about the required creationIdentifier, how modes affect parameter usage, what selectedAngles/selectedGenders/selectedEthnicities contain, and what the return value looks like. This is inadequate 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 description coverage is 0%, so the description must compensate for 11 undocumented parameters. It does add context for variationMode via the mode list and for gridCols/gridRows, aspectRatio, resolution via defaults. However, it completely omits meaning for required creationIdentifier, selectedAngles, selectedGenders, selectedEthnicities, and prompt, leaving these opaque.

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+resource combination: 'Generate image-variation grid.' It immediately distinguishes this from sibling tools like magnific_images_generate or magnific_images_upscale by focusing on the 'variation grid' concept. The enumeration of modes (angles, demographics, etc.) further clarifies the tool's scope.

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 by listing modes and defaults but provides no explicit guidance on when to choose this over alternatives. 'Modes: angles|demographics|expressions|age|storyboard|custom' offers context but does not state exclusions or name alternative tools for other image manipulation tasks. This is clear context without explicit when-to-use/when-not-to-use direction.

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 are all false (write-op, non-idempotent), so the description's "Create" is consistent and adds value beyond them. It discloses the return payload shape (a numeric id), the compatibility property of that id (same id Spaces uses), and a non-goal (no LoRA training). It does not discuss duplicate-creation behavior or failure modes, but for a creation tool with minimal annotations, it provides meaningful extra context.

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 earning its place: core purpose, return-value usage, and a clarifying non-goal. The content is front-loaded and free of filler. The parenthetical "(same id Spaces uses)" is a compact, high-value clarification rather than redundancy.

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 covers the essential loop—create from images, get an id, use that id in generation refs—which is the core knowledge an agent needs. Gaps include missing conditional-parameter guidance (e.g., when 'gender' vs 'productType' applies), potential duplicate outcomes from non-idempotent calls, and image sourcing requirements. Still, it is largely complete for a creation tool with no output schema.

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

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

Schema description coverage is 0%, so the description must compensate. It adds real semantic value: the image-count bound "1-6 images" for the 'images' array and the expanded enum meanings "(character/product/location)" for 'type'. However, it leaves 'name', 'gender', 'description', and 'productType' unexplained, including which optional fields apply to which asset type—a notable gap for handling the 6 parameters correctly.

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+resource+scope: "Create a reusable library asset (character/product/location) from 1-6 images." It clearly distinguishes this from siblings like magnific_library_list (listing) and magnific_images_generate (generating images) by framing it as asset-library creation. The parenthetical enum values align with the schema's 'type' property.

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 actionable downstream guidance: "Use the returned numeric `id` in generation refs (same id Spaces uses)." This tells the agent when this tool fits into a workflow (preparing reusable refs for generation). "No LoRA training" sets expectations about what this tool is not. It lacks explicit exclusionary language naming alternatives, but the usage context is clear.

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 cover read-only, idempotent, and non-destructive nature. The description adds little beyond that, except mentioning the 'library://' URI scheme in results, which gives some hint about return format. 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.

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

The description is extremely concise, using two short sentences with no redundant words. It is well-structured and to the point, fitting the simple list operation.

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?

While the basic purpose is clear, the description lacks details about output format, pagination, error handling, or the meaning of the parameters. Given there is no output schema, this leaves significant ambiguity for users.

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 description provides no explanation of the parameters (page, type, scope, search, perPage). Without guidance, users cannot infer how these affect the listing. The schema enums and types are present but their meanings are unclear.

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 indicates a listing operation for a library, enumerating item types (characters, styles, elements, locations). The phrase 'for agent reasoning' adds context about its intended use. It is specific enough to understand the tool's core function.

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 alternatives is provided. The note 'Picker assets use library://' hints at a use case but does not clarify when this list operation is preferred over other library-related tools or how the scope/type parameters should be used.

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 read-only is false (write operation), destructive is false, and idempotent is false. The description adds context that it generates a GLB file and requires prior image upload, but it does not disclose any side effects, such as cost, rate limits, or whether it overwrites existing creations. Given that annotations are minimal and do not cover behavior beyond safety, the description provides some value but not rich detail.

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, with only three sentences. It front-loads the core purpose ('Image-to-3D GLB'), then provides key usage steps and model options. Every sentence adds value: prerequisite, animation link, and model defaults. No fluff or redundant content.

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 moderate complexity (6 parameters, no output schema), the description is fairly complete for a basic generation tool: it covers purpose, prerequisite, model selection, and a follow-up. However, it omits information about output (since no output schema) and does not define the effect of parameters like faceLimit or textureQuality, which could affect generation choices. This is a reasonable minimum viable description.

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 schema has 6 parameters, but the description only mentions the 'model' parameter (listing options) and implicitly references 'creationIdentifier' through the upload prerequisite. Schema description coverage is 0%, meaning the description adds little semantic value for parameters like 'faceLimit', 'resolution', 'textureQuality', and 'folderReference'. Since the schema itself provides types and enums, the description only partially compensates, warranting a baseline score of 3.

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 purpose: 'Image-to-3D GLB', which indicates the verb (generate) and resource (3D GLB from an image). It also mentions an animation tool ('models3d_rig') and lists available models, distinguishing it from other generation tools in the sibling set (e.g., magnific_images_generate). However, it does not explicitly contrast with sibling tools, only hints at the workflow.

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 by stating 'Upload external images first' and 'Animate with `models3d_rig`', providing clear prerequisite and follow-up actions. However, it does not explicitly state when to use this tool over alternatives, nor does it mention any exclusions, which would be helpful given the large number of sibling generation 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 already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the time range constraint (default 7 days, max 30), but does not mention output format details or that it requires a project/folder reference, which is partially covered by 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?

The description is a single concise sentence, front-loaded with the purpose and includes the key default behavior. No unnecessary 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 the tool's simplicity (2 params, no output schema, annotated as read-only and idempotent), the description provides the essential information but misses some context like how the 'reference' identifies the project/folder and what the report includes. It is minimally 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?

With 0% schema description coverage, the description must compensate. It hints at the 'days' parameter via 'Last 7 days default, max 30', but does not explain the 'reference' parameter at all. This is insufficient for the required 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 clearly states it produces an English markdown status report for a project/folder, which is specific and distinct from sibling tools. It could further clarify what constitutes a 'status report', but the verb+resource are explicit.

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 is given on when to use this tool versus alternatives. It only provides a time default (7 days, max 30), which is parameter-related, not usage context. There is no mention of prerequisites or exclusions.

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

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

Annotations provide readOnlyHint=false, destructiveHint=false, but no detailed safety profile. The description adds behavioral context about the returned webUrl and when to invoke a subsequent tool, which goes beyond 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?

The entire description is two short sentences, front-loaded with the core purpose and follow-up instruction. No filler or redundancy.

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 create tool with two string params and no output schema, the description gives the core purpose and a sharing hint. However, it omits prerequisites, error handling, and references a tool not in the sibling list, leaving the workflow slightly incomplete.

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 0% and the description does not explain the `name` or `description` parameters beyond their existence. It only hints at the response containing `space.webUrl`, not parameter semantics.

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 'Create empty Space' with a specific verb and resource. It differentiates from sibling tools like magnific_spaces_edit and magnific_spaces_list, making the purpose unmistakable.

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

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

The description provides a follow-up workflow: share `space.webUrl` and only call `spaces_show` when inline preview is requested. However, it does not explicitly contrast with alternative creation or editing tools, and references a 'spaces_show' tool not present in the sibling list, weakening its guidance.

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

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

Annotations are all false and provide little signal about behavior. The description adds useful context beyond annotations: this is an external MCP tool, the edit is launched asynchronously, and completion requires polling. It does not mention side effects or permissions, but the non-read-only nature is already implied by the edit action and `readOnlyHint: false`.

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 short sentences with no filler or redundancy. It front-loads the core action and then gives the necessary workflow steps. 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?

The workflow guidance is helpful, but the tool has 7 undocumented parameters, no output schema, and minimal annotations. The description does not explain what a 'Space edit' does, what `query` means, or what the result/return state will look like. This is inadequate 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?

The schema has 7 parameters, including required `query` and `spaceId`, with 0% schema description coverage. The description does not name or explain any parameter, so it completely fails to compensate for the low schema coverage. The agent would have no guidance on how to populate these fields.

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 action: 'Start headless Space edit.' It also distinguishes this tool from sibling status/state tools by prescribing follow-up with `spaces_edit_status` and `spaces_state`. It does not explain what kinds of edits can be performed, so it is not maximally specific.

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 async workflow: start the edit, poll `spaces_edit_status` until `allTerminal`, then verify with `spaces_state`. The 'External MCP only' line adds a usage constraint. It lacks explicit when-not-to-use or alternative edit methods, so it is not a full 5.

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 description discloses key behaviors: it long-polls up to `timeoutSeconds` (default 25, max 25), is snapshot-only when timeoutSeconds is 0, and terminates into `spaces_state`. The annotations already state readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the description adds useful operational details (polling behavior, timeout specifics) without contradicting 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?

The description is extremely concise, using domain-specific shorthand and code-like references. Every word adds value: it explains the wait mechanism, timeout behavior, snapshot mode, and terminal state. Front-loaded and efficient with zero unnecessary prose.

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 (a polling wait operation) and the annotations (readOnly, idempotent, non-destructive), the description is appropriately complete. It covers the polling behavior, timeout, snapshot condition, and endpoint state. The lack of an output schema is compensated by the clarification that it ends at `spaces_state`.

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 description explicitly explains the `timeoutSeconds` parameter (default and max), which is valuable given 0% schema coverage. However, the other three parameters (runId, threadId, operationId) are not described at all. With no schema documentation either, the description only partially compensates for the parameter semantics gap.

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 tool 'waits' for a `spaces_edit` operation, similar to `creations_wait`, and ends at `spaces_state`. It clearly identifies the action (polling/waiting) and the resource (`spaces_edit`), and distinguishes it from other wait tools by referencing the specific flow. It does not fully disclose what `spaces_state` returns, but the core purpose is clear.

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 when to use it: after `spaces_edit` is initiated, similar to `creations_wait` from the sibling set. It provides context on timeout defaults and snapshot behavior. However, it does not explicitly state when NOT to use it or mention alternative tools like `magnific_spaces_run_status` or `magnific_flows_wait`, though the reference to `creations_wait` partially covers this.

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?

Read-only and idempotent are already in annotations, but the description adds awareness of view permission and cost/performance characteristics (cheaper than full board). This goes beyond the structured annotations, providing extra 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.

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

One sentence, front-loaded with 'Read-only,' and packs all necessary information without redundancy. Every word earns its place, making it extremely concise and well-structured.

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 a simple read operation, and annotations cover safety. Description adds permission and cost details, and explains output involves nodes and connections. However, it omits explanation of currentPageId, and the lack of parameter details leaves minor gaps.

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

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

Schema has 0% description coverage. The description mentions only nodeIds implicitly by saying 'scoped to nodeIds,' giving partial meaning. spaceId and currentPageId are not explained at all, leaving two of three parameters under-specified.

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 retrieves nodes scoped to nodeIds plus their connections, distinguishing it from spaces_state. It explicitly mentions read-only and cost efficiency, making the purpose specific and 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?

It directly references the alternative (spaces_state) and explains when to use this tool (for a subset of nodes, cheaper than full board). It also notes the view permission prerequisite, giving clear usage 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 disclose readOnlyHint=true and destructiveHint=false. The description adds minimal behavioral context (e.g., 'lean', 'raw TOON text') but does not explain output format, pagination, or any side effects beyond what annotations cover.

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 short but cryptic; it uses unclear terminology and lacks logical flow. It is not concise because clarity is sacrificed, and the three sentences do not convey essential information efficiently.

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 4 parameters, no output schema, and no annotation beyond read-only, the description is severely incomplete. It fails to explain parameters, return format, or usage constraints, making it inadequate for reliable agent invocation.

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 0% and the description provides no explanation of parameters (page, query, perPage, ownership). The agent must infer parameter semantics from names alone, which is insufficient for correct usage.

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 suggests the tool lists spaces but uses unclear jargon ('TOON text', 'lean catalog'). It mentions sharing webUrl and references spaces_show, which partially clarifies purpose but does not clearly define what the tool returns or its scope.

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 some guidance: use spaces_show for inline canvas preview and avoid creations_search. However, it does not explain when to use this tool versus other spaces tools or when NOT to use it, leaving gaps in decision-making.

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 are neutral (readOnlyHint=false, destructiveHint=false etc.), and the description adds the key behavioral detail that this is an asynchronous operation requiring polling via spaces_run_status. However, it does not disclose other side effects, return values, or potential costs, which would be helpful given the lack of explicit annotation hints. The description carries part of the burden but could be richer.

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 extremely concise—one sentence plus a compact list of modes and a poll reference. Every word adds value, and the key action is front-loaded. No redundant phrasing or verbose explanations.

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 asynchronous run tool, the description covers the core aspects: what it does, the modes, and how to track completion. It doesn't mention return values or error handling, but since there's no output schema and the status tool is referenced, the absence is acceptable. It is sufficiently complete for an agent to invoke correctly.

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

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

Schema coverage is 0%, so the description must explain parameters. It explicitly clarifies that startNodeId is the starting point ('from startNodeId') and explains the mode enum values, including the default. It does not describe spaceId, but that parameter is self-explanatory from its name. This is a solid compensation for the lack of 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 the tool runs a Space workflow from a specific starting node, using a specific verb ('Run') and resource ('Space workflow'). It distinguishes from sibling tools like spaces_run_status (polling) and flows_run (different resource type) by naming the exact function and mentioning the polling companion.

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 provides context on usage modes, including a default mode ('connected default'), and explicitly advises polling with spaces_run_status after running. While it doesn't state when not to use this tool or compare with alternatives like flows_run, the polling hint and mode explanation give clear usage direction for a typical asynchronous workflow.

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 read-only and idempotent, but the description adds useful detail: long-poll up to 25s, in-progress returns poll_after_seconds, and terminal state leads to creations_show. No contradiction 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.

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

Two concise sentences that deliver the essential information without redundancy. Each 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?

Covers polling behavior, timeout limit, and terminal next-step, which is sufficient for this polling tool. Lacks details about response fields, but no output schema is provided, so this is acceptable.

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 description explains timeoutSeconds (long-polls up to 25s) and implies workflowRunIdentifier by context, compensating for the lack of schema descriptions. It doesn't explicitly define workflowRunIdentifier, but its name is self-explanatory.

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 polls spaces_run status, and the context about timeout and terminal behavior makes its 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?

It explains when to use (poll a spaces_run) and what to do on terminal state (call creations_show), but doesn't explicitly distinguish from alternatives like magnific_spaces_edit_status or magnific_creations_wait.

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 and idempotentHint, so safety is covered. The description adds useful context: 'Needs view perm' (authorization) and 'scope=all: whole board (costly)' (performance/cost). 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.

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

Three sentences, front-loaded with 'Read-only board context'. No wasted words, but the cryptic 'raw TOON' could be clearer. Structure is logical: purpose, defaults, permission.

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 6 parameters and no output schema, the description covers core usage (defaults, scope, permissions) but omits details for selectedConnectionIds and currentPageId. It also doesn't describe response structure, but output schema is absent so that's less critical. Overall adequate but with gaps.

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

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

Schema coverage is 0%, so description must compensate. It explains scope (defaults, scope=all), pageId, and selectedElementIds, but does not clarify currentPageId, selectedConnectionIds, or spaceId. Also, it mentions 'pageIndex' which is not a parameter, causing confusion. Partial compensation.

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 it reads board context, a clear resource and action. However, the phrase 'raw TOON' is ambiguous and not explained, which slightly detracts from clarity. It distinguishes from sibling tools like get_nodes by focusing on overall state.

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 clear guidance on default behavior (current page + pageIndex), how to get other pages via pageId, and the costly scope=all option. It also notes the view permission prerequisite. However, it does not explicitly compare with alternative tools or mention 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.

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

The description discloses key behavior: it can save to a folder (mutation) and is rate-limited. Annotations (readOnlyHint=false, destructiveHint=false) align with this, but side effects beyond saving are not elaborated.

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 and free of fluff, conveying the core purpose and key usage variations in three short sentences.

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 covers main functionality but lacks details on error cases, exact return format, and the meaning of 'type'. Given the absence of an output schema, some information is missing for complete understanding.

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 description explains 'folder_reference' (for saving) and 'ids' (for bulk), but 'type' is not explained, and 'id' is obvious. Parameter coverage is partial; schema descriptions are absent.

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 primary function: returning a signed download URL for a stock item. It also distinguishes from related tools like magnific_stock_get and magnific_stock_search by focusing on download/save functionality.

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

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

Usage is implied (for downloading stock items), and bulk support via 'ids' is mentioned. However, there is no explicit guidance on when to use this tool over alternatives or 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.

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe read operation. The description adds that it returns 'preview URL, dimensions, formats, author' and supports bulk execution via 'ids', which is useful. However, it does not disclose any potential limitations (e.g., rate limits, required authentication) or behavior for invalid IDs. With annotations covering the safety profile, a 3 is appropriate.

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 the main purpose and key return fields, followed by a note on bulk support. Every sentence earns its place; no fluff or redundancy. It is concise and well-structured.

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 3 parameters, no output schema, and annotations that cover safety. The description explains the return fields and bulk support, which is helpful. However, it does not explain the 'type' parameter or any prerequisites (e.g., authentication via 'authenticate' or 'connect' tools). Given the moderate complexity and lack of output schema, the description is adequate but could be more complete by clarifying the 'type' parameter and any required setup.

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 0%, so the description must compensate. The description mentions 'ids' for bulk support, which adds meaning to the 'ids' parameter. However, it does not explain the 'id' parameter (though it's required and self-explanatory) or the 'type' parameter (which has an enum of photo/vector/video/icon). The description adds some value for 'ids' but leaves 'type' unexplained, which could be important for filtering or specifying the stock type. Given the low coverage, a 3 is fair.

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 purpose: 'Full details for a single Freepik stock item: preview URL, dimensions, formats, author.' It uses a specific verb ('get') and resource ('stock item'), and lists the key data fields. It distinguishes from siblings like magnific_stock_search and magnific_stock_download by focusing on retrieval of full details for a single item, though it doesn't explicitly name those 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?

The description implies usage: to fetch full details for a stock item, and mentions bulk support via 'ids'. However, it does not explicitly state when to use this tool versus alternatives like magnific_stock_search (for searching) or magnific_stock_download (for downloading). The context of 'single item' vs 'bulk' is clear, but no explicit exclusions or alternative tool names are provided.

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

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

Annotations already declare read-only and idempotent behavior, so the description needs to add context. It adds concrete return-value information (IDs, titles, types, preview URLs), which helps the agent understand the outcome. However, it does not mention pagination or filtering behavior beyond the basic search.

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 extremely concise, uses one short sentence for the main purpose and a second for tool differentiation. No wasted words, and the structure naturally front-loads the primary 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?

For a search tool with 4 parameters, no output schema, and 0% schema description coverage, the description provides the essentials but lacks important context around pagination and content-type filtering. The existence of related sibling tools and annotations strengthens the overall context, but the description alone is not fully self-sufficient.

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 0%, so the description must compensate for all parameters. It only implies the 'query' parameter via 'by keyword' but does not document 'page', 'per_page', or 'content_type'. The enum values for content_type are visible in the schema, but the description adds no meaning beyond that, leaving pagination semantics 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?

The description clearly states a specific action ('Search Freepik stock catalog by keyword') and the resource searched. It also distinguishes itself from siblings by explicitly directing users to stock_get for full details and stock_download for file URLs.

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 explicit context on when to use this search tool versus the related stock_get and stock_download tools. It could be more explicit about alternative search tools, but the sibling references give clear usage direction.

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 signal non-read-only and non-destructive behavior, so the description does not need to restate that. It adds useful context about bulk execution via 'ids', but does not disclose side effects, what happens to the stock item, or what response/state the agent should expect.

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 short sentences, front-loads the core purpose, and adds the key bulk-support detail without any filler. 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?

With no output schema, minimal annotations, and 0% parameter documentation, the description should compensate by explaining inputs, behavior, and expected results. It only covers purpose and sequencing, leaving significant gaps around how to supply title/folder_reference and what the conversion produces.

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 0%, so the description carries the burden of explaining parameters, but it only mentions 'ids' for batched execution. The individual meanings of 'id', 'title', and 'folder_reference' are left entirely to the schema names, which is insufficient for correct invocation.

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 a specific verb ('Convert') and clearly names both source ('Freepik stock item') and target ('Pikaso creation'), making the tool's purpose immediately clear. It also distinguishes itself from related stock tools like magnific_stock_download by focusing on conversion to a creation rather than downloading.

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 phrase 'Use after user selects from stock_show' gives explicit sequencing context, which is valuable for an agent deciding when to invoke this tool. However, it does not explicitly name alternatives or state when not to use the tool, so it stops short of full guidance.

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

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

The description adds useful behavioral details: audio from each clip with no external audio bed, and that it returns a queued creation (async operation). It also implies a prerequisite (completed creations). No contradiction with annotations exists.

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 extremely concise, two sentences, with the core purpose front-loaded. No filler or redundant information.

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 clarifies the return type ('queued creation') and adds audio handling details. However, it lacks elaboration on parameter usage and any potential side effects beyond concatenation. It is adequate but leaves gaps for an agent to interpret.

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 only implicitly covers creationIdentifiers (the videos to concatenate). It does not explain the meaning of 'name' or 'folderReference'. The description fails to compensate for the lack of schema documentation on two of three parameters.

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 it concatenates completed video creations into one MP4, distinguishing it from other video tools like generate or plan. The mention of video_plan ties it to that workflow.

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 it is used to assemble multi-clip plans from video_plan, but does not explicitly state when to use it versus alternatives, nor when not to use it. It provides context but no exclusions or explicit alternatives.

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?

Despite annotations providing no hints (all false), the description discloses a critical behavioral requirement: the tool returns identifiers that must be passed to `creations_show` for results to render. It also warns about image reference format ('never `webUrl`') and directs to `video_models_list` for limits. These go beyond the annotations, though it doesn't explicitly state side-effects like credit consumption or creation of a persistent resource.

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 dense but every sentence/class performs a distinct job: primary action, prerequisite workflow, model selection, image ref rules, limits, and post-processing. It's not as terse as a two-sentence example, but it stays on-point and avoids fluff, with a logical flow from preparation to follow-through.

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?