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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions real-time event forwarding, which is useful, but fails to disclose critical traits: whether this is a mutating operation (likely yes, given 'Add'), permission requirements, rate limits, error handling, or what happens on success/failure. For a tool with 11 parameters and no annotations, this leaves significant gaps in understanding its 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 appropriately sized (two sentences) and front-loaded with the core purpose. The first sentence covers the action, resource, and destination types efficiently. The second adds behavioral context (real-time forwarding). There's no wasted text, though it could be slightly more structured (e.g., bullet points for types).

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 complexity (11 parameters, no annotations, no output schema), the description is incomplete. It doesn't explain the tool's mutating nature, authentication requirements implied by parameters, schema modes, or what the tool returns. For a configuration tool with many options, more context on behavior, outcomes, and error cases is needed to be fully helpful.

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 schema already documents all parameters thoroughly with descriptions and enums. The description adds minimal value beyond the schema—it lists the three destination types (http, mqtt, websocket) which are already in the 'dest_type' enum, and mentions 'real-time' forwarding which isn't parameter-specific. No additional syntax, constraints, or interdependencies are explained, meeting the baseline for high schema coverage.

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

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

The description clearly states the action ('Add a forwarding destination') and resource ('to a stream'), specifying the supported destination types (HTTP webhooks, MQTT brokers, WebSocket endpoints). It distinguishes from siblings by focusing on forwarding configuration rather than analysis, creation, or listing operations. However, it doesn't explicitly differentiate from potential similar tools like 'conduit_create_stream' or 'conduit_create_transform' beyond the forwarding aspect.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing stream), exclusions, or comparisons with sibling tools like 'conduit_create_stream' for stream setup or 'conduit_ingest' for data input. The context is implied (configuring event forwarding) but lacks explicit usage instructions.

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

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

With no annotations, the description carries full burden but only states the function without disclosing behavioral traits like permissions needed, rate limits, or side effects. It mentions 'optimal' but doesn't clarify criteria or limitations.

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

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

The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part earns its place by clearly stating the tool's function and outcome.

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

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

Given no annotations and no output schema, the description is adequate for a single-parameter tool but lacks details on return values or behavioral context. It covers the basic purpose but could be more complete for an analysis 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 description coverage is 100%, so the schema already documents the 'payload' parameter. The description adds minimal semantics by specifying it as a 'sample JSON payload to analyze', aligning with but not significantly 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 action ('analyze') and the resource ('JSON payload'), specifying the outcome ('optimal ClickHouse schema with compression codecs'). It distinguishes from siblings like 'conduit_get_schema' by focusing on analysis rather than retrieval.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'conduit_get_schema' or 'conduit_create_stream'. The description implies usage for schema optimization but lacks explicit context or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively adds context beyond the input schema by stating that it 'runs as a background job with progress tracking,' which clarifies execution mode and monitoring aspects. However, it lacks details on permissions, rate limits, or error handling, leaving some behavioral traits unspecified.

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 appropriately sized and front-loaded, consisting of two concise sentences that directly convey the tool's purpose and key behavioral trait. Every sentence earns its place without redundancy or unnecessary elaboration, making it efficient and easy to parse.

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

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

Given the tool's complexity (background job with 4 parameters) and no annotations or output schema, the description is moderately complete. It covers the core action and execution mode but lacks details on output format, error conditions, or integration with sibling tools. This leaves gaps for an AI agent to fully understand the tool's behavior in context.

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% description coverage, providing clear documentation for all parameters (stream, from, to, destination_ids). The description adds no additional parameter semantics beyond what's in the schema, such as format details or usage examples. According to the rules, with high schema coverage, the baseline score is 3, as the schema does the heavy lifting.

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

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

The description clearly states the action ('replay historical events') and target resources ('from a stream to one or more forwarding destinations'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'conduit_ingest' or 'conduit_list_events', which might handle similar stream operations, leaving some ambiguity about its unique role.

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

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

The description implies usage for replaying historical events as a background job, but it doesn't specify when to use this tool versus alternatives like 'conduit_ingest' (for real-time events) or 'conduit_backfill_status' (for monitoring). No explicit exclusions or prerequisites are mentioned, relying on contextual inference.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions what information is returned (progress, events, errors) which is helpful, but doesn't address important behavioral aspects like: whether this is a read-only operation, authentication requirements, rate limits, polling behavior, or what happens when jobs complete/fail. For a status-checking tool with zero annotation coverage, this leaves significant gaps.

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 perfectly concise - a single sentence that front-loads the core purpose and efficiently lists the key information returned. Every word earns its place with zero wasted text or redundancy.

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

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

Given no annotations and no output schema, the description provides basic purpose and return information but lacks important context. For a status-checking tool, it should ideally describe the response format, error conditions, and typical usage patterns. The description is minimally adequate but leaves the agent guessing about behavioral details that would be crucial for proper tool invocation.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters. The description doesn't add any parameter-specific information beyond what's in the schema. It mentions 'backfill job' which aligns with the parameters but provides no additional syntax, format, or usage details. Baseline 3 is appropriate when schema does all the parameter documentation work.

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

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

The description clearly states the tool's purpose: 'Check the status of a backfill job' with specific details about what information is returned ('progress, events processed, errors'). It distinguishes from sibling tools like 'conduit_backfill' (which likely initiates backfills) by focusing on status monitoring. However, it doesn't explicitly differentiate from other status-checking tools that might exist.

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

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

The description implies usage context (monitoring ongoing backfill jobs) but doesn't explicitly state when to use this tool versus alternatives. The input schema provides some guidance (job_id is optional for listing all jobs), but the description itself lacks explicit when/when-not instructions or named alternatives for similar monitoring functions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context about auto-detection of schema from the first event, which isn't obvious from the input schema alone. However, it doesn't cover other behavioral aspects like permissions needed, rate limits, or what happens if creation fails.

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

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

The description is extremely concise with just two sentences, front-loading the core purpose and following with a key behavioral detail. Every word earns its place, with no redundant or unnecessary 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 creation tool with no annotations and no output schema, the description is minimally adequate. It covers the basic purpose and a key behavioral trait (auto-detection), but lacks details on prerequisites, error handling, or what the tool returns, which would be helpful given the complexity of data stream creation.

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 description coverage is 100%, so the input schema already documents both parameters thoroughly. The description adds minimal value beyond the schema by implying that only a name is needed for creation, but it doesn't provide additional semantic context or usage examples for the parameters.

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

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

The description clearly states the action ('Create a new data stream') and resource ('data stream'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this from sibling tools like 'conduit_create_transform' or 'conduit_backfill', which also involve creation operations in the same domain.

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 some implicit guidance by mentioning that 'schema is auto-detected from the first event,' suggesting this tool is for initial stream setup rather than schema definition. However, it lacks explicit when-to-use instructions or alternatives among sibling tools like 'conduit_create_transform' or 'conduit_ingest'.

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

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

With no annotations, the description carries full burden but lacks critical behavioral details: it doesn't mention permissions needed, whether creation is idempotent, error handling, or what happens if a transform with the same name exists. It only describes the code format and available helpers, which is insufficient for a mutation tool.

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

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

Two sentences are front-loaded with the core purpose, followed by technical details about code format and helpers. It's efficient but could be slightly more structured by separating usage notes from parameter semantics.

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 creation tool with no annotations and no output schema, the description is incomplete: it doesn't cover success/failure responses, side effects, or integration with other tools like conduit_preview_transform. The lack of behavioral transparency and usage guidelines leaves significant gaps.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds minimal value by clarifying that 'code' is a JS function body for transforming events and listing available helpers, but doesn't explain parameter interactions or constraints 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 action ('Create a new transform') and resource ('for a stream'), specifying it's for event transformation using JavaScript code. It distinguishes from siblings like conduit_create_stream (creates stream) and conduit_list_transforms (lists transforms).

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

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

No guidance on when to use this tool versus alternatives like conduit_preview_transform (for testing) or conduit_list_transforms (for viewing). It mentions available helpers but doesn't specify prerequisites or exclusions, leaving usage context unclear.

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

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

No annotations are provided, so the description carries the full burden. It states the tool submits feedback but doesn't disclose behavioral traits such as whether it's a read-only or mutating operation, authentication requirements, rate limits, response format, or confirmation of submission. This leaves significant gaps in understanding how the tool behaves beyond its basic purpose.

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

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

The description is a single, efficient sentence that front-loads the purpose ('Submit feedback to the Conduit team') and includes relevant examples without unnecessary details. Every word contributes to understanding the tool's use, making it appropriately concise and well-structured.

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

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

Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is minimally complete. It covers the purpose but lacks details on behavior, response, or integration context. Without annotations or output schema, more guidance on what happens after submission would improve completeness, but it's adequate for a basic feedback 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 description coverage is 100%, so the schema already documents all parameters (category, message, context) with descriptions and enum values. The description adds no additional meaning beyond what the schema provides, such as examples or usage tips for parameters, meeting the baseline for high schema coverage.

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

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

The description clearly states the action ('Submit feedback') and the target ('to the Conduit team'), with specific examples of feedback types (bugs, feature requests, improvements, praise). It distinguishes from siblings by focusing on feedback submission rather than data operations like 'conduit_create_stream' or 'conduit_list_streams', though it doesn't explicitly contrast with them.

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

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

The description implies usage for submitting various types of feedback (bugs, feature requests, etc.), providing some context. However, it lacks explicit guidance on when to use this tool versus alternatives (e.g., no mention of other support channels) or any prerequisites or exclusions, leaving usage somewhat open-ended.

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

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

With no annotations, the description carries full burden but provides minimal behavioral context. It states it 'gets' schema, implying a read-only operation, but doesn't disclose permissions needed, rate limits, error conditions, or whether it returns live or cached data. This leaves gaps for a tool that likely interacts with a data system.

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

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

The description is a single, efficient sentence that front-loads the core purpose with no wasted words. It directly communicates the tool's function without unnecessary elaboration.

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 low complexity (single parameter, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose but lacks details on usage context, behavioral traits, or output format, which could help an agent use it correctly in a workflow with 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?

Schema description coverage is 100%, so the schema already documents the 'stream' parameter fully. The description adds no additional meaning beyond implying the schema is retrieved for the specified stream, which is redundant with the schema's description. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the action ('Get') and the resource ('current schema for a stream'), specifying what information is retrieved (columns, types, codecs). It distinguishes from siblings like 'conduit_analyze_schema' by focusing on retrieval rather than analysis, but doesn't explicitly contrast them.

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't mention if this is for checking schema details before operations like 'conduit_create_transform' or 'conduit_ingest', or how it differs from 'conduit_analyze_schema' in terms of use cases.

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

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

No annotations are provided, so the description carries the full burden. It mentions schema auto-detection and evolution, which adds some behavioral context beyond basic ingestion. However, it lacks critical details like authentication requirements, rate limits, error handling, or whether this is a write operation (implied by 'Send' but not confirmed). For a tool with no annotations, this is insufficient.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Send one or more events to a stream') and adds useful context ('Schema is auto-detected and evolves'). There is no wasted verbiage, and every part earns its place by clarifying the tool's behavior.

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

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

Given 2 parameters with full schema coverage and no output schema, the description is moderately complete. It covers the basic action and schema behavior but lacks details on usage guidelines, error cases, or integration with sibling tools. For a tool with no annotations and multiple siblings, it should provide more context to be fully helpful.

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 schema fully documents the two parameters ('stream' and 'events'). The description adds no additional meaning about parameters beyond what the schema provides (e.g., format examples or constraints). Baseline score of 3 is appropriate as the schema handles parameter documentation adequately.

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

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

The description clearly states the action ('Send') and resource ('events to a stream'), with additional context about schema auto-detection and evolution. It distinguishes from siblings like 'conduit_list_events' or 'conduit_create_stream' by focusing on ingestion rather than listing or creation. However, it doesn't explicitly contrast with all siblings (e.g., 'conduit_backfill' might also involve sending events).

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't mention when to choose 'conduit_ingest' over 'conduit_backfill' for historical data or 'conduit_feedback' for corrections. The description implies usage for sending events but lacks explicit context or exclusions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'optional pagination and time range filters' which adds some context about capabilities, but fails to address critical behavioral aspects like whether this is a read-only operation, potential rate limits, authentication requirements, error conditions, or what format the events are returned in. The description is too minimal for a tool with 5 parameters.

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

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

The description is extremely concise - a single sentence that efficiently communicates the core functionality. Every word earns its place with no redundant information. The structure is front-loaded with the main purpose ('Query events from a stream') followed by key optional features.

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

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

Given the tool has 5 parameters, no annotations, and no output schema, the description is insufficiently complete. It doesn't explain what 'events' are in this context, what format they're returned in, whether there are any constraints beyond the documented parameters, or how errors are handled. For a query tool with multiple filtering options, more context is needed for effective 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%, so the schema already fully documents all 5 parameters. The description adds minimal value by mentioning 'optional pagination and time range filters' which loosely corresponds to 'limit/offset' and 'from/to' parameters, but doesn't provide any additional semantic context beyond what's in the schema descriptions. This meets the baseline for high schema coverage.

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

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

The description clearly states the action ('Query events') and resource ('from a stream'), making the purpose immediately understandable. However, it doesn't differentiate this tool from potential sibling tools like 'conduit_stream_stats' or 'conduit_time_range' that might also involve event data, leaving some ambiguity about its unique role.

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

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

The description implies usage for retrieving events with filtering options, but provides no explicit guidance on when to use this tool versus alternatives like 'conduit_stream_stats' or 'conduit_time_range'. It mentions optional features but doesn't specify scenarios where these filters are particularly useful or when other tools might be more appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions listing 'all' streams, which implies a comprehensive read operation, but lacks details on pagination, rate limits, authentication needs, or output format. This is a significant gap for a tool with zero 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 a single, clear sentence with no wasted words. It's front-loaded with the core action and resource, making it highly efficient and easy to parse. Every part of the sentence contributes directly to understanding the tool's 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 lack of annotations and output schema, the description is incomplete. It doesn't explain what the output looks like (e.g., list format, fields included), behavioral aspects like pagination or sorting, or how it integrates with other tools. For a list operation, more context is needed to be fully actionable.

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 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, and it appropriately doesn't mention any. A baseline of 4 is applied for zero-parameter tools, as there's nothing to compensate for.

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

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

The description clearly states the action ('List all') and the resource ('data streams in your Conduit account'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'conduit_list_events' or 'conduit_list_transforms', which follow a similar pattern for different resources.

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't mention whether this is for browsing all streams versus filtering or searching, nor does it reference sibling tools like 'conduit_stream_stats' for detailed metrics. The description only states what it does, not when it's appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only operation ('List') but does not specify permissions, rate limits, error conditions, or output format. The added context about transforms being JS functions is helpful but insufficient for a mutation-free tool with zero 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 two sentences with zero waste: the first states the purpose, and the second provides essential context about transforms. It is front-loaded and appropriately sized, earning its place efficiently.

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

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

Given the tool's low complexity (one parameter, no output schema, no annotations), the description is minimally adequate. It explains what transforms are but lacks details on output format, error handling, or integration with sibling tools, leaving gaps for the agent to infer behavior.

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

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

Schema description coverage is 100%, with the single parameter 'stream' documented as 'Stream name'. The description adds no additional parameter semantics beyond what the schema provides, such as format examples or constraints, so it meets the baseline for high schema coverage.

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 verb ('List') and resource ('all transforms configured for a stream'), with additional context about what transforms are ('JS functions applied to events before forwarding to destinations'). However, it does not explicitly differentiate from sibling tools like 'conduit_list_streams' or 'conduit_list_events', which reduces it from a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as needing an existing stream, or compare it to related tools like 'conduit_create_transform' or 'conduit_preview_transform', leaving the agent without 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?

With no annotations provided, the description carries the full burden. It discloses key behavioral traits: the non-persistent nature ('without persisting') and what the tool returns ('transformed output and execution time'). However, it lacks details about error handling, performance implications, or authentication requirements that would be helpful for a mutation-like operation.

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 perfectly concise with two sentences that each earn their place: the first explains the core action and constraint, the second specifies the return values. It's front-loaded with the most important information and contains zero 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 complexity (testing code transformations), lack of annotations, and no output schema, the description does well by explaining the non-persistent nature and return values. However, for a code execution tool, additional context about security sandboxing or error formats would make it more complete, preventing a perfect score.

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 schema already documents all three parameters thoroughly. The description doesn't add any additional meaning about the parameters beyond what the schema provides (stream name, JS function body, sample JSON event). The baseline of 3 is appropriate when the schema does the heavy lifting.

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 specific action ('Preview a transform'), the resource ('by running it against a sample payload'), and the key distinction from siblings ('without persisting'). It differentiates from tools like 'conduit_create_transform' by emphasizing it's a preview/test operation rather than a persistent change.

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

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

The description provides clear context for when to use this tool ('to test' a JS function on sample data without persistence). However, it doesn't explicitly mention when NOT to use it or name specific alternatives (like 'conduit_create_transform' for actual implementation), which prevents a perfect score.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves statistics, implying a read-only operation, but doesn't specify if it requires authentication, has rate limits, returns real-time or historical data, or handles errors. For a tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Get ingestion statistics for a stream') and adds specific details ('event count, rate, schema version') without redundancy. Every word earns its place, making it highly concise and well-structured for quick understanding.

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 low complexity (1 parameter, no nested objects) and 100% schema coverage, the description is adequate for basic understanding. However, with no annotations and no output schema, it fails to provide behavioral context or return value details, leaving gaps in completeness for a tool that might involve data retrieval nuances.

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% description coverage, with the parameter 'stream' documented as 'Stream name'. The description adds no additional meaning beyond this, such as format examples or constraints. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.

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

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

The description clearly states the action ('Get ingestion statistics') and specifies the resource ('for a stream'), with details on what statistics are retrieved ('event count, rate, schema version'). It distinguishes from siblings like 'conduit_list_streams' or 'conduit_list_events' by focusing on metrics rather than listing. However, it doesn't explicitly differentiate from all siblings, such as 'conduit_backfill_status', which might also involve stream status.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'conduit_list_events' for event details or 'conduit_backfill_status' for backfill progress. It lacks context on prerequisites, like needing an existing stream, or exclusions, such as not being suitable for real-time monitoring. This leaves the agent without clear usage direction.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool is 'useful before starting a backfill,' which hints at a read-only, informational role, but doesn't explicitly state if it's safe, requires permissions, has rate limits, or what the output format looks like. For a tool with zero annotation coverage, this leaves significant gaps in understanding its 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 extremely concise and front-loaded: it states the purpose in the first clause and adds context in the second. Every sentence earns its place, with no wasted words, making it easy 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 low complexity (1 parameter, no output schema, no annotations), the description is adequate but incomplete. It explains the purpose and usage context but lacks details on behavioral traits like safety or output format. For a simple read operation, this is minimally viable but leaves room for improvement in transparency.

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% description coverage, with the single parameter 'stream' documented as 'Stream name.' The description doesn't add any meaning beyond this, such as explaining what constitutes a valid stream name or providing examples. Since the schema does the heavy lifting, the baseline score 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 clearly states the tool's purpose: 'Get the time range and total event count for a stream.' It specifies the verb ('Get') and resource ('time range and total event count for a stream'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'conduit_list_events' or 'conduit_stream_stats', which might offer overlapping functionality.

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

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

The description provides clear context for when to use this tool: 'Useful before starting a backfill.' This implies it's a preparatory step for the 'conduit_backfill' sibling tool. However, it doesn't explicitly state when not to use it or name alternatives, such as whether 'conduit_stream_stats' might serve a similar purpose.

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