Moltline Outbound Engine

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint as true, false, and false respectively. The description adds useful behavioral context beyond annotations: the error-handling pattern ('returns an error object never a protocol error') and the fact that it is safe to retry after correcting input. It also clarifies that it is free. A 4 because it doesn't specify rate limits or volume constraints, but the added detail is substantial.

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 (12 sentences) and front-loaded: the first sentence states the core purpose. Every sentence adds value—purpose, cost, checks performed, example input/output, usage guidance vs. siblings, and error-handling behavior. 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 moderate complexity (2 parameters with 100% schema coverage, an output schema present, and comprehensive annotations), the description is complete. It covers what the tool does, when to use it, what it checks, example format, limitations (not for subject line), and error behavior. The output schema documents return values, so the description appropriately focuses on usage guidance.

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 baseline is 3. The description adds semantic value by giving a concrete example of input ('subject': 'Quick question', 'body': '<email text>') and explicitly noting that the subject may be empty when auditing body copy alone. This clarifies usage 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?

The description uses a clear verb+resource pair ('Audit outreach copy') and specifies the purpose is to check 'for spam triggers and deliverability risks.' It differentiates from siblings by explicitly naming subject_line_scorer and sequence_planner, and the provided example clarifies 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 explicitly states when to use the tool: 'Use on the body of an outreach message.' It also gives clear when-not-to-use instructions: 'Not for the subject line alone (subject_line_scorer) and not for the send schedule (sequence_planner).' This provides excellent differentiation from 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 adds value beyond annotations by detailing the exact error format ('returns {"error": ...}') and retry safety ('always safe to retry'). While annotations already state readOnly and idempotent hints, the description enriches with concrete error behavior and examples. 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 a moderate length but front-loads the core purpose clearly. Each sentence adds unique value: purpose, typical example, usage guidance, sibling differentiation, error handling. Could slightly reduce redundancy (e.g., mentioning 'FREE' is already in the title), but overall efficient 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?

Given the simple single-parameter input, rich annotations (readOnly, idempotent), and included error handling details, the description fully covers what an agent needs. It explains input constraints, expected output format, error behavior, retry safety, and when to choose alternatives. The presence of an output schema reduces the need to describe 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% with 1 parameter ('slug'), and the description provides a concrete example ('linkedin-outreach') and sources the parameter from an external tool ('exactly as returned by list_products'). This adds practical context beyond the schema description, such as validation and source of valid values.

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 'free gateway skill' with its 'complete instructions' for a product. It specifies the exact verb ('Load') and resource ('free gateway skill'), and distinguishes it from siblings like 'get_full_skill' by noting differences in input and plan requirements.

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 when-to-use guidance: 'Use when the caller wants usable instructions immediately.' It also specifies when not to use it ('Not for the product's other skills') and names the alternative ('get_full_skill with a skill_name, which requires a paid plan'). Additionally, it covers error handling behavior for invalid inputs, making invocation 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description goes beyond these by detailing the error behavior ('returns an error object' instead of a protocol error), the idempotent/read-only nature for safe retries, and the premium license requirement. No contradictions.

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 includes a concrete example of input/output. It is slightly longer than minimal due to the thorough error behavior and recovery details, but every sentence adds significant value. Could be tightened by merging the second sentence on typcial structure, but still efficient.

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, detailed annotations, and a single parameter with full schema coverage, the description covers everything: purpose, when to use vs alternatives, error handling, idempotency, and license requirement. It is complete without being redundant.

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 the single parameter 'slug' with a clear description. The description adds value by showing a concrete example return structure and noting the source for valid slugs (list_products), which aids correct invocation. Since schema coverage is 100%, baseline is 3, and this 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 starts with a clear verb+resource combination: 'Load one product in full: its persona plus every paid skill.' It also distinguishes itself from siblings like get_full_skill and list_products, 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 explicitly states when to use this tool ('when the caller wants the whole product') and when not to ('Not for a single skill... and not for a free look'), naming specific sibling tools as alternatives. It also provides error recovery guidance, which is exceptional.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description adds significant context: 'Every call is read-only and idempotent, so after correcting the input it is always safe to retry' and describes error handling behavior ('never raises a protocol error — it returns {"error": ...}'). 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 moderately long but front-loaded with purpose and premium status. Each section (purpose, example, usage guidance, error behavior) earns its place. Minor redundancy with annotations but still efficient. Could be slightly tighter.

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 parameters (no enums), an output schema, and sibling tools, the description covers all essential aspects: purpose, usage context, example, error handling, and retry safety. It is fully sufficient for an agent to correctly select and invoke 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% (all parameters documented), so baseline is 3. The description adds value beyond schema by explaining the slug comes from list_products and skill_name from the product's 'skills' array, and provides a concrete example of typical input and output. This enriches the parameter meaning.

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 'one paid skill's complete instructions from a product.' It distinguishes itself by explicitly mentioning it is for paid skills (not the free gateway skill) and contrasts with get_free_skill and get_full_product. The verb 'load' plus resource 'paid skill' 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 explicitly says 'Use when the caller wants one specific paid skill' and immediately provides exclusions: 'Not for the free gateway skill, which get_free_skill returns with no plan, and not for every skill at once (get_full_product).' This gives clear guidance on when to use and when not to, naming sibling 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, and destructiveHint. The description adds rich behavioral context beyond that: it specifies the exact return structure (object with slug, name, tagline, skills, free_skill), explains error behavior (returns error object, never protocol error), explicitly says 'Every call is read-only and idempotent', and advises that retrying after input correction is safe. 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 well-structured and front-loaded with the core purpose. Each sentence adds value: the count, included skills, cost, argument count, return format, slug usage hints, and exclusions. The error-handling section is a bit lengthy but informative. Could possibly be tightened slightly, but overall efficient for the richness of 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 tool's zero parameters, rich annotations, and presence of an output schema, the description fully compensates for any gaps. It covers purpose, return value structure, error behavior, usage boundaries, and retry safety. It is complete for an agent to select and invoke correctly, even for a complex server with multiple sibling tools.

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 parameters and is already fully covered (100%). The description adds no param info because there are none to document. Baseline is 4 for 0 params, but the description proactively confirms 'Takes no arguments', which provides clarity and pre-empts any confusion, justifying a 5.

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 'the 7 outbound products with their included skills' and explicitly notes it is 'FREE' and takes no arguments. It distinguishes itself from siblings by listing what the returned data is (metadata only) and what it is not (no persona text, no skill instructions), and names alternatives like get_free_skill and search_catalog.

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 when to use this tool ('when the caller wants to see what this server covers'), and when not to ('Not for keyword search across the whole 138-product catalog'), naming a specific alternative (catalog server's search_catalog). It also warns against using it for instructions that get_free_skill provides.

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 the error handling behavior (never raises a protocol error, returns error object) and confirms read-only and idempotent nature, which adds context beyond the annotations that already declare readOnlyHint and idempotentHint. It also explains the clamping behavior for days and touches.

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 a brief overview, a concrete example, usage guidance, and error handling notes. Every sentence serves a purpose and the key information 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?

Given the tool's complexity (3 parameters, simple output schema), the description fully covers purpose, usage, behavior, parameters, and error handling. The output schema exists and the description explains the return format with an example, making it complete for an AI agent.

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 has 100% coverage with descriptions for all three parameters. The description adds value by showing a typical input example and explaining the output structure, but the schema already documents defaults and ranges well. The description does not add new info beyond the schema, but the baseline is 3 and the example enhances 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 the tool plans an outreach cadence with expanding gaps and per-touch purposes. It specifies the verb (plan), the resource (outreach cadence), and provides a concrete example of input and output, distinguishing it from siblings like audit_copy.

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 cadence and per-touch purpose are the question. Not for the wording of any single message (audit_copy).' This provides a clear when-to-use and when-not-to-use directive, naming an alternative sibling tool.

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 goes further by detailing error behavior ('never raises a protocol error — returns error object') and affirming idempotency with retry guidance. This adds value 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 well-structured with front-loaded purpose, followed by scoring details, example, use cases, exclusions, error handling, and idempotency note. The word 'FREE' is minor fluff, but overall each 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?

Given the tool has a single parameter, output schema exists, and annotations cover safety, the description covers everything necessary: purpose, input/output format, scoring criteria, use cases, exclusions, error handling, and idempotency. No gaps identified.

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

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

Schema coverage is 100%, so the description adds limited value. It reinforces the 20-item limit and gives a typical input example, but the schema already documents the parameter adequately. Baseline score 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 scores and ranks up to 20 email subject lines, best first. It explicitly differentiates from siblings audit_copy and the creator server's headline_analyzer, 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 explains when to use the tool ('when several subject lines need ranking against deliverability and curiosity signals') and provides explicit exclusions for article headlines and message bodies. However, it could also mention when not to use it relative to other sibling tools like utm_builder or sequence_planner.

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 as safe. The description reinforces these and adds critical detail about error handling (returns JSON error object, never protocol error), which goes beyond 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?

Well-structured with purpose first, then example, then usage boundaries, then error behavior. Every sentence adds value, though slightly longer than minimal could be; still clear 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?

For a simple tool with 6 parameters and an output schema, the description covers purpose, usage constraints, error behavior, and idempotency. Everything an agent needs to invoke it correctly is present.

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. The description adds value through a typical input/output example that demonstrates how parameters map to the tagged URL, though it does not cover optional parameters like term and content.

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 builds a UTM-tagged URL for campaign tracking, provides a concrete example, and explicitly distinguishes it from sibling tools like audit_copy, which is for message body content.

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 (build one tracking URL) and when not to (analyzing results, message body). Names the alternative sibling (audit_copy). Also notes safety of retry after correcting input errors.

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