Moltline Business Suite

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds meaningful context beyond them: the tool never raises a protocol error, it returns a structured {'error': ...} payload with a concrete example, and retries after correction are safe. The 'FREE' cost note and the infinite-runway edge-case behavior are also 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?

Front-loaded with the purpose and the FREE marker, then examples, then usage and error behavior. It is somewhat long with two inline JSON snippets, but each snippet demonstrates a distinct output mode (finite vs. infinite runway), so the length is largely earned.

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 3-parameter read-only calculation, the description covers the purpose, the preconditions, the exclusion, the failure mode, and both output branches, even though an output schema already exists. Nothing an agent needs in order to call it correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3; the description goes further by showing how the three parameters interact in a worked example (revenue netted against burn producing net_burn_monthly) and by stating what happens when revenue covers burn. That operationalizes monthly_revenue's semantics better than the schema text 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?

States a specific verb and resource: 'Compute months of cash runway and the projected out-of-cash date.' It also names the sibling it is not for ('Not for per-unit profitability (unit_economics)'), so an agent can disambiguate without opening schemas.

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

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

'Use when a cash balance and a monthly burn are known' gives the positive precondition, and 'Not for per-unit profitability (unit_economics)' gives the explicit exclusion plus the alternative to route to.

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/destructive hints, but the description adds behavior they cannot: it never raises a protocol error and instead returns a structured {error} payload with recovery guidance, and it states retries are safe after correction. It also discloses that exactly one skill is auto-selected with no plan needed, which is non-obvious routing 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?

Front-loaded with the core action and return shape, then disambiguation, then error contract. Slightly long with the redundant example input/output restatement, but nearly every sentence adds routing or behavioral 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?

Output schema exists and the description still covers the important non-obvious pieces: error payload shape, no-plan requirement, single-skill selection, and retry safety. Nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 100% and the single slug parameter is already fully documented with format and non-empty constraint, so the description's example input largely restates the schema. Baseline 3 is appropriate when the schema carries the parameter burden.

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

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

States a specific verb (load) and resource (a product's free gateway skill) and explicitly contrasts with get_full_skill, which handles the product's other skills. An agent can immediately tell which of the two skill tools applies.

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

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

Gives an explicit when-to-use trigger ('Use when the caller wants usable instructions immediately'), an explicit when-not ('Not for the product's other skills... need get_full_skill with a skill_name, which requires a paid plan'), and points to list_products as the recovery path for bad slugs.

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, idempotent, non-destructive, closed-world, so the bar is lower – yet the description adds context beyond them: the PREMIUM license requirement and a precise error contract (never raises a protocol error, returns {"error": ...} with an example) plus retry safety after correction. That is meaningful behavioral disclosure the annotations do not carry.

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

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

Front-loaded with purpose and examples, and the alternative routing is near the top. Slightly redundant: 'Returns persona plus every skill for one product' restates the opening sentence, and the error sentence is long, but overall it earns its space.

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 an output schema present, the return shape needn't be explained, yet the description shows it anyway; combined with license requirements, error semantics, retry safety, and sibling routing, an agent has everything needed to call it correctly.

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

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

Schema coverage is 100% and the slug parameter is fully documented, including 'exactly as returned by list_products' and non-empty constraint. The description adds only a typical input example and an example error string, which is a marginal gain over the schema – 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?

Opens with a specific verb and resource: 'Load one product in full: its persona plus every paid skill.' It explicitly names the sibling tools it is not (get_full_skill, list_products, get_free_skill), so an agent can route correctly without opening any schema.

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

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

Gives both sides: 'Use when the caller wants the whole product' plus explicit exclusions for a single skill (get_full_skill) and for a free look (list_products, get_free_skill). No inference is required.

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/non-destructive, but the description adds material context beyond them: the PREMIUM license requirement, the no-protocol-error error contract with a concrete example payload, and the explicit 'safe to retry after correcting input' guarantee. It also discloses the return shape even though an output schema 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 core purpose and the alternatives are front-loaded before the example payload. Slightly longer than necessary — the example input/output pair partly duplicates the output schema — but no sentence is filler.

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 two-param read tool with full schema coverage, an output schema, and rich annotations, the description covers everything an agent needs: selection criteria, exclusions, license precondition, and error/retry semantics. Nothing material is missing.

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

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

Schema description coverage is 100% and both params are documented there with the same examples (slug from list_products, skill_name from the skills array), so the description cannot add much. The inline example input echoes the schema without new format or edge-case guidance, which is the expected baseline-3 outcome.

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

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

States a specific verb+resource ('Load one paid skill's complete instructions from a product') and names the exact scope (one named skill, selected by skill_name). It explicitly contrasts with get_free_skill and get_full_product, so the agent can route without opening schemas.

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

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

'Use when the caller wants one specific paid skill' gives the positive selection condition, and the following sentence gives two explicit exclusions mapped to their alternatives (get_free_skill for the free gateway skill, get_full_product for everything at once). This is textbook when/when-not/alternatives 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 readOnly, idempotent, closed-world, and non-destructive, so the safety profile is covered. The description adds real value beyond that: it states the return is metadata only (no persona text, no skill instructions) and documents that invalid input returns an {'error': ...} object rather than a protocol error, making retries safe.

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

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

Front-loads purpose, then return shape, then routing guidance, then error semantics – a sensible order. Slightly padded by the 'FREE.' fragment and the long error sentence, but nearly every clause carries actionable 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?

For a zero-argument listing tool with an output schema and full annotations, the definition covers everything an agent needs: what it returns, what it omits, which slug values to pass downstream, which siblings to prefer, and how failures surface.

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?

Zero parameters, so baseline is 4. The description confirms 'Takes no arguments' and shows a typical input of {}, which is consistent with the empty schema but largely redundant with it.

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

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

States a specific verb and resource with scope: 'List every product in the Business Suite line with its included skills.' It also explicitly bounds the scope ('not for keyword search across the whole 138-product catalog'), which lets an agent separate it from search_catalog and get_free_skill without inspecting schemas.

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

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

Gives an explicit positive trigger ('Use when the caller wants to see what this server covers') plus two named exclusions with the alternative tool for each (search_catalog for keyword search, get_free_skill for actionable instructions). The decision boundary is fully specified.

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=false, and openWorldHint=false. The description adds important behavioral context beyond annotations: invalid input never raises a protocol error, returns an {error: ...} object with remediation, and retry is safe after correcting input.

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 and output values, then moves through usage, error behavior, and retry safety. It is slightly longer than strictly necessary for a simple math tool, but the structure is clear and most sentences contribute useful 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 the simple computation, complete parameter schema, annotations, and presence of an output schema, the description is complete enough to use the tool correctly. It covers purpose, example input/output, appropriate use, exclusions, and error handling.

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 all three parameters are already documented with types, ranges, and constraints. The description reinforces the parameters through a typical input example, but it does not add substantial semantic meaning beyond what the schema already provides.

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

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

The description states a specific verb and resource: computing an amortized loan payment, including monthly payment, total paid, and total interest. It also distinguishes the use case from interest-free installment schedules, so the agent can identify the correct tool without opening sibling schemas.

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

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

It explicitly says to use the tool for a fixed-rate amortized loan and explicitly says not to use it for interest-free schedules, naming installment_plan as the alternative for that case. This gives 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 cover readOnly/idempotent/non-destructive, and the description adds behavior annotations don't carry: the error contract (never raises a protocol error, returns {"error": ...} with fix guidance), the retry-safety implication, and a worked example of output 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?

Front-loaded with purpose, then example, then usage guidance, then error behavior — all load-bearing. The 'FREE.' fragment is a minor non-sequitur and the error paragraph is dense, but nothing is redundant.

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 two-parameter pure computation with an output schema, everything an agent needs is present: correct inputs, expected output, error handling, and retry safety.

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, but the worked example (unit_cost 12 + target_margin_pct 60 → 30.0) demonstrates how the two parameters interact and clarifies margin-not-markup semantics, adding real value over the field docs.

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 first sentence states a specific verb and resource (compute the selling price for a target margin), and the description explicitly frames itself as the inverse of unit_economics, so an agent can discriminate it from siblings without opening schemas.

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

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

It gives both sides of the routing decision: 'Use when the margin is the fixed requirement' and 'Not when the price is already set,' with unit_economics named as the inverse alternative.

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

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

Annotations already cover read-only, idempotent and non-destructive, so restating those adds little. The description still contributes real context: it discloses that errors never surface as protocol errors but return {"error": ...}, gives an example message, and notes which output fields are conditional on cac. Only the repetition of annotation-supplied safety hints keeps it from a 5.

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

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

Front-loaded with purpose, then concrete input/output example, then usage, then error semantics — a sensible ordering with no filler sentences. The error paragraph is a touch long but each clause carries operational value for retry decisions.

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 everything an agent needs for a 6-parameter calculation tool: typical call shape, conditional outputs, exclusions, and non-obvious failure semantics. An output schema exists, and the description appropriately summarizes rather than re-specifying return values.

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% and the schema already documents each field including the cac>0, fixed_costs_monthly>0 gating rules. The description's example input shows a typical combination, which is mildly useful, but the "LTV fields appear when cac is provided" note duplicates the schema's own wording. Baseline 3 applies.

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

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

Specific verb plus resource ("Calculate unit economics") followed by the exact outputs it produces: margin, break-even, LTV:CAC. It also names the two sibling tools it is not (cash_runway, target_price), so the agent can route without opening schemas.

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

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

Explicit positive condition ("Use when price, variable cost, and fixed costs are known and margin or break-even is the question") plus two explicit exclusions with the correct alternative named for each. When/when-not/alternatives are all present.

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