Moltline Studio

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

Beyond the annotations (readOnlyHint, idempotentHint), the description adds valuable behavioral details: it returns exactly one skill, never raises a protocol error, returns an error object with fix guidance, and states 'Every call is read-only and idempotent, so after correcting the input it is always safe to retry.' This enriches the annotation data with concrete error 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?

The description is dense but each sentence serves a purpose: what it does, example I/O, differentiation from sibling, error behavior, and idempotency. It is front-loaded with the core action and stays information-dense 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?

With only one parameter and rich annotations plus an output schema, the description still adds crucial context: automatic selection of the free skill, no plan required, error response format, and retry safety. It fully covers all operational aspects for an agent to invoke this 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?

The schema already covers the single param (slug) with a clear description and example. The tool description adds a concrete input example and shows the expected output structure, which reinforces parameter usage beyond the schema. Since schema coverage is 100%, baseline is 3; the example input/output pushes it to 4.

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: 'Load a product's free gateway skill with its complete instructions.' It clearly distinguishes this tool from the sibling get_full_skill by stating it returns only the free gateway skill and explicitly saying 'Not for the product's other skills: those are named and need get_full_skill with a skill_name.'

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 context: 'Use when the caller wants usable instructions immediately.' It also names the alternative tool for other skills and even notes the plan requirement, giving clear when-to-use and 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. Description adds value by stating the payload is large, error handling returns JSON with fix instructions, and reinforces idempotency. 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?

Description is well-structured with front-loaded purpose. Each sentence adds value, though the example payload could be trimmed. Still efficient and 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 tool's simplicity (1 param, output schema exists, annotations rich), the description covers purpose, usage, constraints, error behavior, and idempotency. No gaps remain.

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

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

Schema coverage is 100% with one parameter. Description adds meaning by explaining the slug comes from list_kits, provides an example value, and gives a typical input. Goes beyond the schema description.

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

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

Description clearly states 'Load a themed kit and every member product in full.' It distinguishes from siblings like 'get_full_product' (single product) and 'list_kits' (just lists kits). The verb+resource scope is 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?

Explicitly says 'Use only after list_kits has confirmed the kit slug' and 'Not for a single product (get_full_product).' Provides clear when-to-use and when-not-to-use with an alternative named.

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 provide readOnlyHint, idempotentHint, and destructiveHint. Description confirms these and adds critical behavioral details: on invalid input it returns an error object (never a protocol error), the exact error format, and the retry safety guarantee. This is valuable context 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 concise with no wasted words. It follows a logical structure: purpose, plan restriction, example, usage guidance, error behavior, and safety note. Each sentence serves a distinct purpose.

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 one parameter and an existing output schema, the description covers purpose, usage context, error handling, content returned, and relationship to siblings. It provides everything an agent needs to select and 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 has 100% coverage with description 'Product slug exactly as returned by search_catalog.' The description adds a helpful example input ('inbox-zero-assistant') that clarifies the expected format, providing slight extra value beyond the baseline.

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 'loads a product's complete persona definition' with specific verb 'load' and resource 'persona definition'. It distinguishes from sibling tool 'get_full_product' by noting this returns only persona text, not skills.

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

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

Explicitly states when to use: 'Use when the caller needs the product's voice and operating rules only.' Provides clear alternative: 'Not when skills are also wanted - get_full_product returns persona and every skill in one call.' Also notes 'PREMIUM (paid plan)' as a prerequisite and explains error recovery.

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 provide readOnlyHint, idempotentHint, and destructiveHint, but the description adds valuable behavioral details: 'never raises a protocol error — it returns {"error": ...}' and 'Every call is read-only and idempotent, so after correcting the input it is always safe to retry.' This 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 description is concise (~150 words) and well-structured: purpose first, then a typical input/output example, usage guidance, and error handling. Every sentence adds value 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?

Given the simple input schema (one required parameter), full annotations, existing output schema, and multiple sibling tools, the description covers all necessary aspects: purpose, usage, error behavior, and an example. It is complete enough for an agent to select and 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 100% with a clear description of the 'slug' parameter. The description adds a concrete example ('inbox-zero-assistant') and reinforces that the slug comes from 'search_catalog', providing extra context beyond the schema.

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

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

The description explicitly states 'Load one product in full: persona plus every skill's instructions', which is a specific verb+resource. It also distinguishes from siblings by naming 'get_full_skill' and 'get_full_kit', making the purpose clear 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 explicit guidance: 'Use when the caller wants the whole product. Not for a single skill (get_full_skill) and not for a bundle of products (get_full_kit).' It also notes the tool is PREMIUM (paid plan), giving a 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 declare readOnlyHint, idempotentHint, destructiveHint. The description adds that the tool never raises protocol errors and returns error objects with fix instructions, which is valuable beyond annotations. 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?

Every sentence serves a purpose: purpose, plan indicator, example, usage guidance, error behavior, safety note. Well-structured 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?

Given the tool's simplicity (2 params, output schema present, rich annotations), the description covers purpose, when to use, error handling, idempotency, and parameter constraints. Complements output schema and sibling list fully.

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

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

Schema coverage is 100% with good descriptions. The description adds context: slug must be exactly as from search_catalog, skill_name must match preview_product's list, and provides a concrete example. This adds value beyond the schema.

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

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

The description clearly states the tool loads a paid skill's complete instructions from a product, specifies it is for premium paid plans, and distinguishes itself from siblings like get_free_skill and get_full_product by naming them directly.

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

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

Explicitly says 'Use after preview_product has shown the skill list' and provides alternatives for free skills (get_free_skill) and bulk retrieval (get_full_product). Also notes idempotency for safe retry after errors.

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?

Beyond the readOnly, idempotent, and non-destructive annotations, the description discloses the error behavior (returns an error object rather than raising a protocol error), the fact that kits are not sold standalone, and that All-Access is how a caller actually unlocks a kit. This adds meaningful operational context 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 front-loaded with the core purpose, then provides return shape, usage routing, error behavior, and safety in a logical order. Every sentence adds necessary information; there is no filler or repetition of schema 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 zero-parameter read-only listing tool, the description is complete: it covers the exact output shape, subscription semantics, when to use it, which siblings to use instead, error behavior, and retry safety. The output schema and annotations further support 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?

The tool has zero parameters, so the baseline is 4. The description reinforces this with 'Takes no arguments' and goes further to explain that even malformed input is handled gracefully via an error object. Nothing more is needed.

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 names a specific verb and resource: 'List the 12 themed kits with pricing and member products.' It also explicitly distinguishes itself from get_full_kit and search_catalog, so an agent can select it without confusion.

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 usage guidance: 'Use when the caller asks about bundles or bundle pricing' and explicitly says what not to use it for, naming search_catalog for individual products and get_full_kit for full kit contents. It also states that retrying is safe after correction.

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. Description confirms these and adds important behavioral details: 'Returns teasers only, never full text' and 'on invalid, missing, or malformed input this tool never raises a protocol error — it returns {"error": ...}'. 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 structured with a front-loaded sentence stating core purpose, followed by an example, usage guidance, error behavior, and a retry note. No redundant or off-topic content. Every sentence serves a purpose.

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?

Simple tool with one parameter, good annotations, and output schema present. Description covers purpose, input, output structure, limitations, error handling, and safe retry. No gaps remain for an agent to invoke incorrectly.

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

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

Schema coverage is 100% with a clear description for the single parameter 'slug'. The description adds a concrete example input and output, which helps but does not significantly extend the schema's own documentation. Baseline of 3 is appropriate.

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

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

The description starts with a clear verb and resource: 'Preview one product: metadata, persona teaser, and paid-skill teasers.' It differentiates from siblings by stating it returns teasers only, never full text, and explicitly names alternatives like get_full_persona and get_free_skill.

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

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

Explicitly states when to use: 'Use to judge a product before committing.' Also tells when not to use: 'Not for the complete persona or skill bodies... and not when the caller wants instructions they can act on now (get_free_skill).' Provides error-handling guidance and retry safety.

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?

Even though annotations already mark the tool as read-only and idempotent, the description adds valuable context: it details error handling (never a protocol error, always returns an error object), confirms safety to retry, gives a concrete output example, and mentions it is free. These details go well 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?

Every sentence in the description earns its place. It opens with a clear purpose, then quickly notes the free aspect, provides a concrete example, explains when to use (and when not), describes error behavior, and reassures safety. Despite covering multiple aspects, it remains tight 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?

For a recommendation tool, the description covers all necessary aspects: purpose, input/output format, usage context, alternative tool, error handling, and safety guarantees. The presence of an output schema means return values don't need elaboration. The description leaves no critical gaps for an agent to use this 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?

The input schema already covers both parameters with descriptions (100% coverage), so the baseline is 3. The description adds contextual value by showing a typical input/output example that illustrates how both parameters are used together, and it explains that limit values outside 1-10 are clamped. That extra context justifies a 4.

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 'Recommend catalog products for a need described in plain language,' which pairs a specific verb and resource with a clear method. It explicitly distinguishes from the sibling 'search_catalog' by stating 'Not for exact keyword or slug lookups,' so the agent can differentiate easily.

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 directly states when to use: 'Use when the caller describes a problem instead of naming a product.' It also explicitly says when not to use and names the alternative: 'Not for exact keyword or slug lookups (search_catalog).' This provides unambiguous 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=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds value by explaining that the tool returns a specific example output format, that an empty query with an area set browses that area, and most importantly, that it never raises protocol errors but returns an error object—a critical behavioral detail not deducible from annotations. The only minor gap is that it doesn't describe any rate limits or authentication needs, but those are not indicated as issues by context signals.

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 highly concise at about 100 words, with every sentence serving a distinct purpose: stating scope and example, usage guidance, error handling, and idempotency. It is front-loaded with the core action and key constraint (free, 138 products), making it efficient 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?

Given the tool's moderate complexity (3 optional parameters, no nested objects, no enums), the description provides a complete picture: purpose, input example, output format, usage boundaries, error behavior, and safety guarantees. An output schema exists, so the description does not need to detail return values. The coverage is thorough for an AI agent to select and invoke this 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 100%, so the baseline is 3. The description adds value by providing a concrete example of a typical input and demonstrating how the parameters work together (e.g., 'empty query with an area set browses that area'), which helps an agent understand parameter interplay beyond the schema's individual descriptions. It also explains the default limit behavior and clamping in the schema, but the description reinforces this with context. It does not introduce new parameter details, but the example compensates.

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

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

The description clearly states the tool searches all 138 catalog products by keyword and/or focus area, which is a specific verb+resource combination. It distinguishes itself from siblings like list_kits and recommend_products by explicitly naming them and stating what they do differently, making the purpose unambiguous and differentiating it effectively.

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 guidance on when to use this tool (when the caller names a keyword, product, or focus area) and when not to use it (not for bundles, use list_kits instead; not for plain-language problem statements, use recommend_products). It names two alternatives, giving clear context 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?

The description adds significant behavioral context beyond the annotations. It explicitly states the tool takes no arguments, always returns a specific JSON structure (including keys), never raises protocol errors (returns error objects instead), and declares the operation read-only and idempotent with retry safety. This is a gold standard in transparency, especially since annotations already confirm readOnlyHint and idempotentHint.

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 well-structured. It uses a front-loaded format with a bolded note on the key value proposition ('FREE'), immediately followed by the no-arguments input, return structure, usage guidance, exclusions, and error behavior. Every sentence adds unique value with 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 the tool's zero complexity (no params, simple output schema), the description is fully complete. It covers input, output, usage context, error handling, behavioral safety, and sibling differentiation. The presence of an output schema reduces the need to describe return values, and the description still mentions the key and structure for convenience.

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 states 'Takes no arguments' for a schema with zero parameters. Schema coverage is 100%, so the baseline is 3. The description goes further by clearly explaining that there are no inputs, which prevents the agent from trying to pass arguments. A score above 3 is justified because the description provides absolute clarity.

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 that this tool explains 'how to unlock full personas, paid skills, and kits' and is FREE. The verb 'explain' and the specific resources (personas, skills, kits) are well-defined, and the sibling tools like get_full_persona and list_kits are implicitly distinguished as they cover individual items or pricing, not the upgrade path.

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 when a premium tool has been refused or the caller asks what a plan covers' and provides a clear negative case: 'Not for per-bundle or per-product pricing' with named alternatives (list_kits, preview_product). This gives the agent excellent guidance on when and when not to use this tool.

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