Moltline Business Suite

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds significant value beyond these: it details the error handling mechanism (never raises protocol error, returns error object with fix instructions), explains the special case when revenue covers burn (returns 'infinite'), and reinforces idempotency with 'after correcting the input it is always safe to retry.' 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?

The description is front-loaded with the core purpose, followed by a concise example, usage guidance, and error handling. Every sentence serves a distinct purpose—no redundancy or filler. Despite being a bit long, it is well-structured and efficiently informative.

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 parameters, 2 required, output schema exists), the description covers all essential aspects: purpose, example, edge case (infinite runway), error handling, and idempotency. The schema already documents parameters and output, so the description complements it fully without 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 100% with clear parameter descriptions, so baseline is 3. The description goes further by providing a concrete example input and output (e.g., cash_balance: 120000, monthly_burn: 15000, monthly_revenue: 5000) and explaining the calculation logic (net_burn_monthly). This adds practical context that aids 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 begins with a clear verb+resource statement: 'Compute months of cash runway and the projected out-of-cash date.' It directly distinguishes from the sibling tool 'unit_economics' by explicitly stating 'Not for per-unit profitability (unit_economics).' This provides strong differentiation.

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 states when to use the tool: 'Use when a cash balance and a monthly burn are known.' It also provides an exclusion: 'Not for per-unit profitability (unit_economics).' Additionally, it explains error behavior and retry safety, giving clear guidance on how to handle failures.

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 detail beyond annotations: it states the tool never raises a protocol error but returns an error object, describes the error format with examples, and confirms every call is read-only and idempotent. This complements the readOnlyHint, idempotentHint, and destructiveHint annotations perfectly without 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 well-structured with clear sections: purpose, example input/output, usage guidance, error behavior, and safety guarantees. Every sentence serves a purpose, and critical information is front-loaded ('Load a product's free gateway skill with its complete instructions'). While verbose, it remains efficient for the 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?

Given the tool has one parameter, an output schema, and annotations, the description covers all necessary context: purpose, input format, output structure, error handling, sibling differentiation, and retry safety. It even references list_products as a prerequisite. 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?

With 100% schema description coverage, the description still adds value by clarifying that the slug must be exactly as returned by list_products and providing an example ('smb-ops-desk'). This gives the agent a concrete reference for constructing valid input beyond the schema's constraints.

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 loads a product's free gateway skill with complete instructions, and explicitly distinguishes it from get_full_skill which handles other skills and requires a paid plan. It also provides a typical input and output example, 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?

It explicitly tells when to use this tool ('when the caller wants usable instructions immediately') and when not to ('Not for the product's other skills: those are named and need get_full_skill with a skill_name, which requires a paid plan'). It also explains error handling and retry safety, leaving no ambiguity.

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. Description adds critical behavioral info: error handling pattern ('never raises a protocol error — it returns {"error": ...}') and reinforces idempotency/read-only. 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?

Starts with a clear one-line summary, then example, then usage clarification, then error details. Every sentence adds value, though there is minor repetition (e.g., 'Returns persona plus every skill' echoes the opening). Overall well-structured and not overly verbose.

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

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

For a tool with one parameter, complete annotations, and an output schema, the description fully covers purpose, usage, error behavior, and return format. It also provides a concrete example and error examples. No gaps remain for typical 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?

Schema coverage is 100% so baseline is 3. Description adds value by providing an example input ('{"slug": "smb-ops-desk"}') and clarifying that the slug comes from list_products, which is helpful context beyond the schema's 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?

Clearly states 'Load one product in full: its persona plus every paid skill' with specific verb (Load) and resource (one product). Explicitly distinguishes from siblings: 'Not for a single skill (get_full_skill) and not for a free look, which list_products and get_free_skill provide.'

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 ('when the caller wants the whole product') and when not to ('Not for a single skill… not for a free look'). Also mentions PREMIUM license as a usage condition and provides error recovery guidance ('safe to retry').

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. The description adds valuable behavioral context beyond annotations: it never raises a protocol error but returns an {"error": ...} object with fix guidance, and explicitly notes retry safety after correcting input. This supplements the annotation coverage.

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 well-structured and front-loaded with purpose, then example, usage, error behavior, and safety. It is slightly repetitive ('Returns one named skill' re-states the purpose) but overall every section earns its place and it is not bloated.

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 an output schema exists, the description need not detail return fields, but it still covers the example return shape. It covers usage context, exclusions, error handling, and idempotent retry behavior. This is complete for a moderate-complexity tool with strong annotations.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds an example input and clarifies skill_name's role ('selected by skill_name'), but the schema already documents both parameters with examples and constraints. No additional meaning is critical.

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 specific verb+resource: 'Load one paid skill's complete instructions from a product.' It clearly distinguishes from siblings by explicitly contrasting with get_free_skill and get_full_product, naming what this tool returns (one named 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?

Provides explicit guidance: 'Use when the caller wants one specific paid skill.' It also states exclusions: 'Not for the free gateway skill... and not for every skill at once (get_full_product)', naming the alternative tools. This is 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 provide readOnlyHint, idempotentHint, and destructiveHint; the description reinforces these by stating 'every call is read-only and idempotent' and adds detailed error handling behavior: 'never raises a protocol error — it returns {"error": ...}'. This goes beyond annotations to fully disclose the tool's 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 well-structured with the main purpose first, followed by return format, usage guidance, exclusions, and error handling. It is slightly verbose (e.g., the error sentence is long) but every sentence adds value. Front-loading is effective, making it easy to scan.

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 (no parameters, no input complexity), the description fully covers all necessary aspects: return format, typical output size, how to use outputs, exclusions, error behavior, and safety guarantees. With an output schema present, the description does not need to detail return values further, but it provides a clear summary anyway.

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 no parameters (0 params), so baseline is 4. The description confirms 'takes no arguments' and describes the typical input/output, adding clarity beyond the empty schema. Although schema coverage is 100%, the description's extra detail (e.g., 'typical input {} returns a list of 30 product objects') justifies the baseline score.

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 verb 'list' and the resource 'every product in the Business Suite line' with its included skills. It also distinguishes from sibling tools by noting that it is not for keyword search across the whole catalog (search_catalog) and not for instructions (get_free_skill), 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 gives clear guidance: 'Use when the caller wants to see what this server covers' and explicitly states when not to use it ('Not for keyword search...' and 'not for instructions the caller can act on'). It also directs the user to alternative tools (get_free_skill, get_full_product, etc.) after obtaining slug values.

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 readOnlyHint, idempotentHint, and destructiveHint. The description adds significant value by explaining error handling behavior ('never raises a protocol error — it returns an error object'), the 'FREE' cost indicator, and the idempotent retry safety. 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 well-structured with clear sections: purpose, caveat, example, usage guidelines, error handling, and safety. Every sentence adds value without redundancy. It is front-loaded with the core 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?

Given the presence of an output schema, the description does not need to detail return values. It covers error handling, usage restrictions, safety, and provides an example. This is complete for effective tool use.

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

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

Schema description coverage is 100% with detailed parameter descriptions. The description includes an example input and output, which helps tie parameters together but does not add new semantic information beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool's verb and resource: 'Compute an amortized loan payment: monthly payment, total paid, total interest.' It also provides an example and distinguishes from the 'installment_plan' tool for interest-free loans, which is not a sibling but is mentioned as an alternative, helping to differentiate 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?

Explicitly states when to use ('Use for a fixed-rate amortized loan') and when not to use ('Not for interest-free schedules'), and names the alternative tool ('installment_plan'). Also includes a caveat ('Administrative math only — not financial advice'). This provides clear guidance for the agent.

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, and the description reinforces these while adding that the tool 'never raises a protocol error' and instead returns a structured error object. It also explains the retry safety after correcting input, which is actionable behavior beyond what annotations provide.

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, followed by a useful example and then usage and error behavior. Every sentence contributes information, and the structure is logical 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 simplicity, the description covers purpose, usage, examples, error behavior, and idempotency. Combined with the comprehensive input and output schemas, an agent has all information needed to invoke the tool correctly without 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?

The schema provides 100% coverage of both parameters with descriptive details, so the description is not required to redefine them. The description adds a concrete example (unit_cost=12, target_margin_pct=60) and output, but this does not introduce new semantics beyond the schema. Thus a baseline 3 is appropriate.

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

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

The description explicitly states 'Compute the selling price needed to hit a target margin percentage' and identifies the tool as the inverse of unit_economics, clearly distinguishing it from that sibling. The verb 'Compute' and the resource 'selling price' make the function unambiguous and 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 explicit when-to-use guidance: 'Use when the margin is the fixed requirement. Not when the price is already set.' It also names the inverse relationship to unit_economics, providing clear context for selecting this tool over 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description reinforces these and adds valuable error behavior: 'on invalid, missing, or malformed input this tool never raises a protocol error — it returns an error object with a fix message.' No contradictions, but additional details like rate limits or auth are absent.

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?

Well-structured single paragraph: purpose first, then example, usage guidelines, error behavior. No unnecessary sentences. The word 'FREE' is minor and doesn't detract. Efficient and 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?

Given 6 parameters, high schema coverage, existing output schema, and clear sibling differentiation, the description covers purpose, input/output examples, conditional behaviors, error handling, and retry safety. An agent can confidently use this 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 100%, so baseline is 3. The description adds a concrete example (price=49, unit_cost=12, fixed_costs_monthly=8000) and explains conditional behavior: 'LTV fields appear when cac is provided.' This enhances understanding beyond schema 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 clearly states 'Calculate unit economics: margin, break-even, LTV:CAC, and a plain reading.' It provides a specific verb and resources, includes an example input/output, and distinguishes from siblings like cash_runway and target_price.

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 guidance: 'Use when price, variable cost, and fixed costs are known and margin or break-even is the question. Not for cash position over time (cash_runway) and not for solving backward from a target margin (target_price).' Also explains error handling and safe retry behavior.

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