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

The verb 'Get' clearly signals a read operation, and the description states what information is returned. However, with no annotations, it does not explicitly confirm side-effect-free behavior, access requirements, or error conditions, though the output schema helps cover the return 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?

The description is a single, front-loaded sentence with no filler. Every word contributes to conveying the tool's core function, making it appropriately concise for a simple getter.

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 one-parameter getter with an output schema, the description is minimally adequate, but it lacks usage context and parameter sourcing guidance. It does not mention how to find the capability_id or when this tool should be preferred over related siblings.

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 0%, and the description does not explain the capability_id parameter beyond what the property title already implies. It does not mention how to obtain a valid capability_id or any format constraints, leaving the agent to infer meaning from the tool name alone.

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

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

The description uses a specific verb ('Get') and names the resource ('one capability's parameter and connection details'), making the tool's purpose clear. It also implicitly distinguishes itself from search_capabilities by focusing on a single capability's details, though it does not explicitly name sibling tools.

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?

There is no explicit guidance on when to use this tool versus alternatives like search_capabilities or get_workflow. The phrase 'one capability' implies a single-capability lookup, but no when-to-use or when-not-to-use context is provided.

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 the full behavioral burden. It discloses idempotency via a unique request_id, revision-conflict handling, server-side validation, and the single-operation constraint. This is unusually transparent 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?

Six short sentences, each carrying critical information: purpose, single-operation rule, allowed types, idempotency, conflict handling, and validation. No filler; constraints are front-loaded for immediate visibility.

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?

The description covers the core behaviors an agent needs: what to submit, how to ensure idempotency, and how to recover from conflicts. The main gap is the lack of per-operation payload schemas (e.g., what fields add_node requires), but the server-validation note and enumerated types reduce the risk of misuse.

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 0%, so the description must add meaning. It explains request_id (idempotency), expected_revision (known revision/conflict), and operations (allowed types, exactly one). It does not detail the internal fields of each operation type, but it does compensate for the schema's complete lack of descriptions.

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

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

The description opens with a specific verb-resource pair: 'Apply Astro Flow operations to a canvas at a known revision.' It also enumerates the exact operation types (add_node, remove_node, set_parameter, connect, disconnect), making it distinct from siblings like get_workflow (read) and submit_workflow (likely full submission) without ambiguity.

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

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

Provides clear usage context: send the edit at a known revision, send exactly one operation, and on revision conflict read the canvas again before retrying. It does not explicitly name alternatives or state when not to use this tool, but the guidance is concrete enough for an agent to apply correctly.

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. The verb 'Read' accurately discloses that this is a non-mutating operation, which is the primary behavioral trait. However, it adds nothing beyond that — no mention of error behavior for missing runs, auth needs, latency, or partial-result possibilities.

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?

A single nine-word sentence with the verb front-loaded and zero filler. Every word contributes meaning, and the returns are listed compactly.

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 one-parameter read tool with an output schema present (so return-value details are covered elsewhere), the description captures the operation, the input, and the key outputs. The only missing context, explicit sibling routing and deeper behavior, is minor for this scale of 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 0%, so the description must compensate. 'A submitted run' does indirectly clarify that run_id refers to the identifier of a previously submitted run, but it does not explain the ID format or how to obtain it. Given the single, semantically obvious parameter, this is adequate but not rich.

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 specific verb ('Read') with a clear resource ('a submitted run') and enumerates what the agent receives back (status, artifacts, errors). It is distinguishable from siblings by resource type — runs versus workflows, capabilities, and canvases — though it does not explicitly name an alternative, so it falls just short of a 5.

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?

Usage is only implied: when you need a run's status, artifacts, or errors, this is the tool. There is no explicit when-to-use/when-not-to-use statement, no mention of alternatives, and no exclusion criteria such as 'use get_workflow for workflow data instead.'

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 must carry the burden of behavioral disclosure. 'Read' adequately signals non-mutating behavior, and specifying that it returns current nodes, links, and revision gives a snapshot-like expectation. However, it does not mention side effects, permissions, or any limitations, leaving some ambiguity for a tool with zero annotation support.

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, information-dense sentence with no filler. It front-loads the verb and specifies the three key components returned (nodes, links, revision), making it highly efficient for an agent 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?

For a simple read operation with one parameter and an output schema, the description is largely sufficient to guide invocation. It does not explain when to use the tool relative to siblings or provide parameter details, but the overall complexity is low and the return structure exists in the output schema.

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 one parameter, canvas_id, but schema description coverage is 0%. The description does not explain the meaning, format, or provenance of canvas_id beyond the parameter name itself. Since the description does not compensate for the lack of schema documentation, parameter understanding relies entirely on inference from the parameter name.

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 specific verb ('Read') and resource ('a canvas') and clearly identifies the exact content returned: current nodes, links, and revision. This clearly distinguishes it from sibling tools like submit_workflow or edit_workflow, which are write operations.

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 clearly implies use when the agent needs the current state of a canvas rather than modifying or submitting it. It does not explicitly name alternatives or exclusion conditions, but the read-only framing provides adequate context for choosing this tool over its mutating siblings.

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?

There are no annotations, so the description carries the behavioral burden. 'List' clearly implies a read-only operation, and 'currently open' provides state context. However, it does not disclose any prerequisites, session requirements, or why openness matters for invocation, and there is no explicit statement about side effects.

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, front-loaded sentence with no filler. Every word contributes meaning: subject, action, resource, and state condition.

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

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

For a zero-parameter, simple listing operation with an output schema, the description is nearly complete. It clearly states what is listed. It could slightly benefit from noting that the tool returns the open canvases (already covered by output schema) or from referencing when one would want this, but nothing critical 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?

The tool has zero parameters, and the rubric establishes a baseline of 4 for such cases. The description does not need to explain parameters, and the schema confirms no inputs are required.

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 specific verb ('List') and a precise resource ('currently open Astro Flow workflow canvases'). The qualifier 'currently open' clearly distinguishes this from tools like get_workflow, which presumably retrieves a specific workflow rather than enumerating open canvases.

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 when to use this tool: when you need to see currently open canvases in Astro Flow. However, it does not explicitly contrast this with alternatives like get_workflow or describe_capability, leaving some inference to the agent.

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

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

With no annotations provided, the description must carry the full burden of disclosing safety and side effects. It only says 'Search,' implying a read operation but never explicitly stating it. It also omits details about what is returned, limits, or any side effects, leaving the agent underinformed.

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 concise sentences: the first states the core purpose, the second adds a useful behavioral note about the query parameter. No redundancy, well-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?

An output schema exists, so return values need not be explained. However, the description omits any guidance on when to use this tool versus describe_capability and doesn't explicitly state it's read-only. It's adequate for a simple search tool but has notable 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 0%, so the description must compensate. It does by explaining that an empty query lists all capabilities, giving practical meaning to the query parameter. However, it lacks formatting details or examples, so it only meets the baseline.

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

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

The description clearly states a specific verb ('search') and resource ('Astro Flow node capabilities'). It distinguishes from siblings like describe_capability by using 'search' rather than 'describe' or 'get', but it doesn't explicitly name alternatives, so it falls short of a 5.

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 the sibling describe_capability or other tools. The only usage hint is about the query parameter (empty query lists all), which concerns parameter behavior, not tool 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, the description carries the full burden of behavioral disclosure. It hints at idempotency via 'unique request_id' and revision-checking via 'known revision', but it does not state side effects, validation failures, or whether execution starts immediately.

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?

A single sentence with no filler; every phrase earns its place by adding a constraint or the core action.

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 state-changing submission tool with no annotations and three required parameters, the description is too thin. It does not explain what happens after submission, how to correlate with get_run, or how errors like revision mismatch are surfaced, even though an output schema exists.

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 0%, so the description must compensate. It adds meaning to expected_revision ('known revision') and request_id ('unique'), but provides no format, constraints, or relationship details for canvas_id.

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 specific verb ('submit') and resource ('canvas for execution') and adds the key constraints of a known revision and unique request_id. It is clear enough to distinguish from siblings like get_workflow or edit_workflow, though it does not explicitly name 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 phrase 'at a known revision' implies the appropriate context for calling the tool, but there is no explicit guidance on when to prefer this over sibling tools or what preconditions must hold before submission.

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