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 discloses the clearing (mutation) behavior, the default dry-run safety, the failed-only default, and the requirement of --allow-write. It also mentions the return type. It stops short of describing irreversibility or the exact effect on DAG runs, but the core behavioral traits are well covered.

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 opening sentences are concise and front-loaded, clearly summarizing the tool's purpose and safety behavior. The Args section is lengthy but structured and provides default values for each parameter. It avoids unnecessary verbosity while containing all necessary 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 an 11-parameter mutation tool with no output schema, the description covers the purpose, safety defaults, required flag, and return behavior. It does not describe the output structure but explicitly states what is returned (cleared or previewed task instances). Overall, the description is sufficiently complete for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so all parameters are documented in the input schema. The description adds value by stating default values for only_failed, dry_run, reset_dag_runs, include_upstream, and include_downstream, which are not fully explicit in the schema. It also clarifies the scoping effect of dag_run_id and task_ids, supplementing the schema 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 clearly states the action ('Clear task instances for a DAG') and the intended outcome ('allowing them to be re-run'). It distinguishes itself from sibling tools like list-task-instances or get-task-instance by focusing on clearing/resetting state, and it adds specific behavior details (failed-only, dry-run) that sharpen the purpose.

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

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

The description provides clear context for when the tool is used (retrying tasks by clearing their state) and notes the critical prerequisite of the --allow-write flag. It also explains the safety default of dry-run mode. However, it does not explicitly name alternatives or exclusions, though the use case is reasonably implied by the reset/retry semantics.

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 transparently states that the operation is asynchronous, that the environment will show CREATING status until ready, that the --allow-write flag is needed, and that the return value is the created environment ARN. This is meaningful context beyond the schema.

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 opening sentence is concise and front-loaded, but the extensive Args/Returns block largely duplicates schema details. This adds length without adding value, though the structured layout keeps it readable. The description is not as tight as it should be.

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 10-parameter create operation with nested objects and no output schema, the description covers essential context: asynchronous behavior, required write flag, and return value. It could go further (e.g., mentioning how to poll status), but it's sufficiently complete for an agent to correctly invoke and interpret initial results.

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 each parameter. The description's Args list adds no new information and even introduces an extraneous 'ctx' parameter not present in the input schema. This repetition without additional semantic value aligns with the baseline 3.

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 creates a new MWAA environment with specific verbs ('Create', 'Creates') and a clear resource ('Amazon MWAA environment'). This distinctly differentiates it from siblings like get-environment, update-environment, and delete-environment.

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: it's for creating new environments, and it notes the async nature ('environment status will be CREATING until ready') and the prerequisite 'Requires the --allow-write flag'. However, it does not explicitly name alternatives or exclusion scenarios, so it stops short of 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 fully discloses critical behaviors: permanent deletion, irreversible operation, asynchronous execution, 'all associated resources' affected, and the --allow-write flag requirement. It also states the return value, exceeding expectations for a destructive 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?

The description is well-organized with a short summary, behavioral notes, and a clear Args/Returns structure. Every sentence adds useful context without unnecessary padding.

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 delete tool with no output schema, the description covers the operation's scope (all resources), irreversibility, async nature, required flag, and return confirmation. This is complete for the tool's complexity.

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 already documents all three parameters with descriptions, and the description merely echoes 'override' for region and profile. No new semantic meaning is added beyond the schema's high coverage, so the baseline 3 is appropriate.

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

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

The description clearly states 'Delete an MWAA environment' and elaborates with 'Permanently deletes the specified MWAA environment and all associated resources.' The verb 'delete' and resource 'MWAA environment' are specific and clearly distinguish this from sibling tools like create-environment, update-environment, and get-environment.

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 conveys that this is for permanent, irreversible deletion and requires the --allow-write flag, establishing clear context for when it should be used. However, it does not explicitly name alternative tools or exclusion conditions (e.g., 'for temporary disable, use update-environment'), so it stops short of a full 5.

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 full burden of behavioral disclosure. It states that the tool returns DAG details, but does not mention error behavior (e.g., if the DAG is not found), permissions needed, or whether it is a read-only operation. For a 'get' tool this is a partial gap, but it still relies heavily on the inferred safety of the verb.

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 structured with a clear opening sentence, but it is padded with a docstring-style args/returns section that largely duplicates the schema. The inclusion of the undocumented 'ctx' parameter adds unnecessary noise, making it less concise than it could be.

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 tool with full schema coverage, the description provides a reasonable summary of what is returned. However, without an output schema or explicit mention of edge cases, it is only minimally complete. The generic return type 'CallToolResult' is not further detailed.

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 covers all parameters at 100%, so the baseline is 3, but the description fails to add value beyond the schema. It lists the same parameters and even introduces a non-existent 'ctx' parameter, which is misleading and reduces 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 specifies the action (get details) and the resource (a specific DAG), distinguishing it from sibling tools like list-dags (which lists DAGs) and get-dag-source (which retrieves source code). The mention of returning schedule, owners, tags, and configuration gives a concrete 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 implies use when you need metadata for a specific DAG, but it does not explicitly state when to prefer this over alternatives like list-dags or get-dag-source. No when-not-to-use or alternative guidance is provided, so it is only implied.

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 burden of disclosing behavior. It does not mention that this is a read-only operation, nor does it describe permission requirements, error conditions, or rate limits. It only lists return content, which 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 well-structured with a clear first sentence followed by Args and Returns sections. It is not excessively verbose, though the Args section largely duplicates schema information. It is front-loaded with the core purpose.

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

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

With no output schema, the description partially compensates by listing the returned fields (state, execution date, etc.), but it is vague about the exact response envelope ('CallToolResult'). It lacks details on error handling, prerequisites, or permissions, making it only minimally complete.

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

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

Schema coverage is 100%, so baseline is 3. The description mostly repeats parameter names and descriptions from the schema, adding no meaningful extra context. The only extra is listing 'ctx' which is not in the schema. No behavioral nuance is added.

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 'Get details of a specific DAG run' with a specific verb and resource, and it distinguishes from sibling tools like list-dag-runs by focusing on a single run. It also lists the exact data returned (state, dates, configuration).

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 context is clear: this tool is for retrieving details of a specific DAG run, as opposed to listing runs. It does not explicitly mention alternatives or exclusions, but the 'specific' in the description implies when to use it.

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 version-dependent behavior (direct fetch on 3.x vs file token resolution on 2.x) and states the return type as CallToolResult with DAG source code. This adds meaningful context beyond a simple read operation, which is especially useful given the absence of annotations.

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

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

The description is front-loaded with the purpose, followed by version behavior and a structured Args/Returns section. While the Args section somewhat duplicates schema details, the overall length is reasonable and the structure is clear.

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 an output schema, the description appropriately states the return type. It also explains version compatibility. The parameters are fully described in the schema, and the tool's read-only nature is evident, making the description sufficient for correct 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?

The input schema has 100% coverage with descriptions for all parameters. The description's Args section merely repeats parameter names without adding new semantics, so it does not enhance the schema's information.

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 that it gets the source code of a DAG file, using a specific verb+resource pattern. It distinguishes from siblings like get-dag by focusing on source code rather than metadata or 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 context about Airflow 2.x and 3.x compatibility but does not explicitly instruct when to choose this tool over alternatives like get-dag. The use case is implied by the tool's purpose, not contrasted with 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?

With no annotations provided, the description carries the full burden for behavioral transparency. The verb 'Get' implies a read-only operation, but the description does not explicitly state that it does not modify resources, what permissions are needed, or how errors are handled (e.g., if the environment does not exist). It only lists return content, which is more about output than behavior.

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

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

The description is well-structured with a clear opening sentence, a useful 'IMPORTANT' note, and a documented Args/Returns section. However, the Args section largely duplicates the schema, which is redundant. Overall it is concise and front-loaded with the core purpose, so it earns a 4.

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 tool with one required parameter and no output schema, the description gives a good overview of what is returned (status, Airflow version, network config, etc.). However, it lacks any mention of error conditions, required AWS permissions, or explicit differentiation from sibling tools like list-environments. It is adequate but not complete for an agent to fully understand the tool's 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%, so the baseline is 3. The description repeats parameter names (environment_name, region, profile_name) with brief explanations that mirror the schema but adds no extra meaning or examples. It provides no additional context about constraints, interactions, or format beyond what the schema already offers.

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 function: 'Get detailed information about an MWAA environment' and enumerates the specific information returned (status, Airflow version, execution role, network configuration, logging settings). The verb 'Get' plus resource 'environment' is specific and distinguishes it from sibling tools like list-environments or create-environment.

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 says 'Use this tool instead of aws mwaa get-environment CLI command', which is a usage guideline but not about choosing between MCP tool alternatives. It does not explicitly say when to use this versus list-environments or other siblings, but the purpose implicitly suggests using it when you need details for a single environment. No exclusions or alternative tool names are mentioned.

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 full burden. It states the tool 'gets' and 'returns' errors, implying a read-only operation, but does not explicitly disclose that it makes no modifications, does not list any side effects, or describe behavior when environment is missing. The description adds minimal transparency beyond the function name.

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 a clear opening sentence, a brief purpose statement, and an Args section. However, the Args section is redundant with the schema and adds length without new information. Still, it is concise overall and front-loaded with the main 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?

There is no output schema, so the description must explain the return value. It only says 'CallToolResult with import errors', which is vague and does not describe the structure of the errors (e.g., filename, error message, severity). Without annotations or an output schema, this is insufficient for an agent to reliably interpret the result.

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 parameters are already well-documented. The description's Args section largely repeats the schema descriptions (e.g., 'AWS region override', 'AWS CLI profile name override') without adding new meaning. The schema also provides additional detail about environment_name auto-detection that the description omits, so the description adds no semantic value.

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 'Get DAG import errors in an MWAA environment' with a specific verb and resource. It further explains it returns 'a list of import/parsing errors for DAG files', distinguishing it from sibling tools like list-dags and get-dag.

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

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

It provides a clear use case: 'Useful for diagnosing why DAGs are not appearing or are broken.' This gives context on when to use the tool. It does not explicitly mention alternatives, but the use case is specific enough to guide 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 of disclosing behavior. It explains return content and the map_index behavior (parent vs. mapped instance), but does not mention permissions, error conditions, or rate limits. The detail about return fields and the parent summary adds some transparency beyond a bare statement.

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 a clear main sentence, a short overview of return values, and an Args/Returns layout. It is slightly verbose (e.g., 'Get details' followed by 'Returns detailed information'), but every section earns its place and the front-loaded purpose makes it easy to scan.

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

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

Given the tool's moderate complexity (7 parameters, no output schema, no annotations), the description covers what the tool returns, how map_index works, and lists all parameters. It lacks explicit error/edge-case behavior, but for a get-by-ID tool it provides sufficient context to invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds one useful nuance (map_index must be >= 0) and clarifies the parent-summary behavior, but mostly restates parameter names and descriptions already in the schema. It also mentions a 'ctx' parameter not present in the schema, which could be slightly confusing.

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 function: 'Get details of a specific task instance.' It specifies the resource (task instance) and the action (get details), and distinguishes itself from siblings like list-task-instances and get-task-logs by listing exactly what details are returned (state, dates, duration, try number).

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 the map_index parameter ('For dynamically mapped tasks...') and explains behavior with and without it. It does not explicitly name alternative tools for other scenarios, but the guidance on mapped vs. unmapped tasks gives sufficient situational context.

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. It discloses pagination behavior via full_content and token, timeout handling (automatically retries in chunked mode for logs >80MB), and the format of responses (CallToolResult with task logs). This is substantial behavioral insight beyond a simple 'returns logs' statement.

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 an opening purpose, a pagination/timeout behavior paragraph, and an Args list. It is slightly verbose due to the Args list duplicating schema properties, but each section adds useful context and the critical details (retry logic, pagination) are 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 10 parameters and no output schema, the description adequately explains the tool's behavior, return type, and edge-case handling (timeouts, large logs). It doesn't cover error cases like nonexistent try_number, but overall it provides a complete picture for an AI agent to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's Args section adds context not fully in the schema: try_number starts at 1, full_content implies chunking with continuation_token, and map_index is for mapped task instances. While partially redundant, it reinforces and clarifies parameter semantics.

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 'Get logs for a specific task instance try' and elaborates 'Returns the execution logs for a task instance at a specific try number.' This specifies the verb (get), the resource (task logs), and the scope (specific task instance try), clearly distinguishing it from siblings like get-task-instance or list-task-instances.

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 'Useful for debugging failed or problematic task executions,' providing clear situational guidance. It doesn't mention exclusions or alternatives, but no other sibling tool retrieves logs, so this is clear context without needing explicit when-not-to-use.

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 takes on the burden of disclosing behavior. It explicitly states that sensitive fields (password, extra) are redacted and describes the return type, which are meaningful behavioral traits. However, it does not explicitly declare read-only status or side effects, but 'list' strongly implies non-mutating 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 main sentence is concise and front-loaded. The Args and Returns sections are structured, but they largely duplicate schema information, adding some redundancy. Overall length is appropriate for a tool with 5 parameters.

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 list operation, the description covers the essential behavior: listing connections, redaction, and return type. With no output schema, it does not detail the structure of connection objects beyond redaction, but the schema covers parameter semantics. The lack of error handling or auto-selection behavior is partially mitigated by the schema, making this sufficient.

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?

All 5 parameters are thoroughly described in the input schema (100% coverage), covering purpose, defaults, and optionality. The tool description merely repeats these in the Args section without adding new meaning. The only additional element is 'ctx', which is a standard MCP context and not a user-facing parameter.

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 'List Airflow connections in an MWAA environment', specifying the verb (list), resource (connections), and context (MWAA environment). This distinguishes it from siblings like list-dags or list-environments, and the mention of redaction adds specificity.

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

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

It implies usage for retrieving connections with clear context (MWAA environment) and mentions redaction, but does not explicitly reference alternatives or when-not-to-use. For a straightforward read operation, the context is sufficient.

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?

Without annotations, the description carries the full burden. It discloses that results are sorted descending by default, includes pagination and filtering parameters, and returns execution dates, states, and run IDs. However, it does not mention permissions, error conditions, or whether the operation is inherently read-only, which would be useful behavioral context.

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 overly long due to a full Args block that largely duplicates the input schema. The opening two sentences are useful, but the extensive parameter list adds little value and makes the description bloated. For an MCP tool, the schema already documents parameters, so this structure is inefficient.

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 10 parameters and no output schema, the description covers key aspects: what is returned, default sorting, filtering, pagination, and AWS region/profile overrides. However, it lacks details on output structure beyond a vague 'CallToolResult', potential errors, or edge cases. It is complete enough for basic use but not exhaustive.

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

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

Schema coverage is 100%, so the baseline is 3. The description repeats much of the schema in its Args list (redundant) but does add some context, such as the default order_by behavior and that results include execution dates, states, and run IDs. This adds marginal value over 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 'List DAG runs for a specific DAG', identifying the verb, resource, and scope. It distinguishes itself from sibling tools like get-dag-run (singular run) and list-task-instances by focusing on DAG runs with details on returned fields.

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 the tool (listing runs for a specific DAG with optional filters) but does not explicitly compare to alternatives or state when not to use it. It gives a clear context for usage, but lacks exclusionary guidance or named 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?

With no annotations, the description carries the full burden. It discloses that it returns a list of DAGs with metadata, but lacks explicit mention of read-only behavior, pagination semantics, or potential errors. It adds some context about returned fields but leaves 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 one-line summary is clear and front-loaded, but the Args block duplicates schema documentation, making it longer than necessary. The structure is organized but could be more concise.

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 provides a basic summary and return type, but lacks details about pagination, optional environment_name fallback behavior, and error cases. For a list tool with six parameters and no output schema, it is minimally sufficient but not comprehensive.

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

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

The schema provides descriptions for 100% of parameters, so the baseline is 3. The description repeats parameter names and meanings without adding significant new information. The inclusion of 'ctx' as an argument not present in the schema is a minor inconsistency.

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 'List all DAGs in an MWAA environment' with a specific verb and resource. It distinguishes from sibling tools like list-environments and get-dag by focusing on DAGs. The mention of returning metadata adds clarity.

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 the tool is for listing DAGs but does not explicitly say when to use it over alternatives. There is no reference to sibling tools or conditions when this is the best choice. The usage context is clear but implicit.

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. It discloses the return value ('CallToolResult with list of environment names') and the regional scope, but omits explicit statements about read-only behavior, pagination, or error handling. The phrase 'List all' implies a read operation, but it is not explicitly stated, leaving some behavioral ambiguity.

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 a clear purpose and uses headers for Args/Returns, making it structurally navigable. However, it is somewhat redundant: the first sentence already states the return, and the Args block duplicates information fully covered by the schema with less detail. The IMPORTANT note is useful but could be integrated more tightly.

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 list tool with no output schema, the description covers the essential aspects: what it lists, the region scope, the return type, and the alternative for detailed info. It lacks any mention of pagination or error behavior, but these are less critical for an environment-name listing, making it adequately complete rather than fully complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description merely restates the parameters as 'region override' and 'profile name override' without adding any semantic detail beyond the schema's explicit defaults and fallback behaviors. No additional value is provided.

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 'List all MWAA environments in the specified region,' a specific verb and resource that clearly states the tool's purpose. It further clarifies the return is 'a list of environment names available in your AWS account for the given region,' and explicitly distinguishes itself from get-environment by directing users there for detailed info.

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

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

Explicit guidance is provided: 'Use get-environment to retrieve detailed information about a specific environment' names the alternative and when to use it. Additionally, 'IMPORTANT: Use this tool instead of ‘aws mwaa list-environments’ CLI command' gives a direct usage directive for MCP agents that might consider the CLI fallback.

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. It discloses what each returned instance includes (map_index, state, start/end times, execution details) and mentions pagination via limit/offset. It does not explicitly state side-effect-free behavior, but 'List' and 'Returns' imply it. The lack of auth/rate-limit info is not critical for a read 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 opening sentence is clear and front-loaded, but the description includes a lengthy Args block that duplicates the schema parameter descriptions. This redundancy makes it longer than necessary. The usage guidance and return details are valuable, but the structure could be tightened.

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?

No output schema exists, so the description must explain return values, which it does (list of instances with fields). It also provides usage context and pagination. Missing failure modes (e.g., what happens if task is not a mapped task) but overall sufficiently complete for a read-only list tool with 8 parameters and no annotations.

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

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

Schema description coverage is 100%, so all 8 parameters are already documented in the schema. The description repeats the same parameter descriptions in an Args block without adding extra meaning (e.g., formats, constraints, relationships). It adds no value 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 verb 'List', the resource 'all mapped instances for a dynamically mapped task', and the context of Airflow's dynamic task mapping. It distinguishes from siblings like 'list-task-instances' and 'get-task-instance' by focusing on map indices.

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 says 'Use this to discover which map indices exist and their states before fetching logs with get-task-logs or details with get-task-instance.' This names specific alternatives and provides a clear sequencing recommendation.

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 that the tool returns a list of task instances with states, start/end times, and execution details, which is useful. However, it omits behavioral traits such as pagination handling, potential errors, or permissions, and does not explicitly confirm read-only behavior beyond the verb 'List'.

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: a clear one-sentence summary followed by a brief output description and a tidy Args/Returns block. It is front-loaded and reasonably concise, though the Args section redundantly duplicates schema descriptions, preventing a perfect score.

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 list operation with 5 parameters and no output schema, the description covers the basic purpose and return content but leaves gaps: no mention of pagination, empty results, or how environment_name auto-detection works (though the schema provides that). It does not describe the structure of each task instance in the returned list, which would be valuable without an 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?

Schema coverage is 100%, so the schema fully documents each parameter. The description's Args section only repeats the parameter names and short descriptions from the schema, adding no additional semantic meaning. It does include 'ctx' as a non-schema parameter, but that is an implementation detail rather than useful parameter guidance.

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

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

The description explicitly states 'List task instances for a specific DAG run' with a concrete verb and resource, and further clarifies the scope by noting it returns all task instances within a DAG run. This clearly differentiates from sibling tools like get-task-instance (singular) or list-mapped-task-instances.

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 ('for a specific DAG run') but does not explicitly state when to use this tool versus alternatives like list-mapped-task-instances or get-task-instance, nor does it provide exclusion criteria. The guidance is inferred rather than explicit.

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 must carry the full burden of behavioral disclosure. It mentions the return value ('Returns a list...with their keys and values') but does not explicitly state that this is a read-only operation, nor does it disclose potential side effects, errors, authentication requirements, or pagination behavior. The absence of these details leaves a significant transparency gap.

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 concise, but the Args section is redundant with the schema information and includes an extra 'ctx' parameter not present in the schema. The Returns line is useful but could be more compact. The structure is clear, but the duplication reduces efficiency.

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

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

Given that there is no output schema, the description partially explains the return format ('list of Airflow variables with their keys and values'). However, it does not describe the exact structure of a variable object, pagination behavior beyond the parameter names, or how defaults are applied. This is sufficient for a simple list tool but lacks depth for a fully contextual understanding.

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% for all five parameters, so the baseline is 3. The description's Args section merely repeats the parameter names and brief descriptions already present in the schema, without adding any additional semantic context or examples. The description adds no value beyond what the schema already provides.

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

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

The description clearly states the tool's purpose: 'List Airflow variables in an MWAA environment.' The verb 'List' and resource 'Airflow variables' are specific, and the distinction from sibling tools (e.g., list-dags, list-connections) is clear because each targets a different resource type.

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: this tool is for listing Airflow variables within an MWAA environment. However, it does not explicitly mention when to use this tool instead of alternatives, nor does it offer exclusions. The context is clear enough to imply the primary use case, so it slightly exceeds baseline.

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 clearly states the mutation effect (setting paused to true), the prerequisite (--allow-write flag), and the return type (CallToolResult confirming the pause). It does not mention edge cases like existing running runs, but the core behavior is well disclosed.

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

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

The description is structured as a docstring with a summary, a note about the flag, an Args list, and a Returns line. While somewhat longer than strictly necessary, every section contributes useful context. The summary and note are front-loaded, and the Args list mirrors schema but is acceptable for documentation completeness.

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 all essential aspects for this simple tool: purpose, effect, prerequisite, parameters, and return value. It does not need to elaborate further given the lack of output schema and the simple nature of the operation. Slightly more detail on edge cases (e.g., idempotency) could push it higher, but it is already complete for an agent to invoke correctly.

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

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

Schema description coverage is 100%, with all parameters (dag_id, region, profile_name, environment_name) already described in the schema. The description's Args section repeats the same information without adding new semantics. Therefore, the baseline of 3 applies; no additional meaning is provided 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 opens with a clear verb+resource: 'Pause a DAG.' It explicitly states the effect ('Sets the DAG's paused status to true, preventing new scheduled runs'), which distinguishes it from sibling unpause-dag. The purpose is unambiguous and specific.

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

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

The description clearly states a prerequisite: 'Requires the --allow-write flag.' It implies usage context by explaining the effect (preventing scheduled runs). It does not explicitly name alternatives or exclusions, but the sibling list includes unpause-dag, and the purpose is clear enough for an agent to infer when to use this tool versus others.

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 a critical behavioral requirement (requires --allow-write flag) and states the return type (CallToolResult with DAG run details). It does not cover side effects or failure modes, but for a trigger operation this is reasonably transparent.

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 a clear one-sentence purpose, a note about the required flag, an Args list, and a Returns section. Every element serves a purpose without redundancy. It is appropriately sized for a tool with 6 parameters.

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?

Despite no output schema and no annotations, the description covers the essential aspects: what it does, the required --allow-write flag, all parameters, and the return type. It could be more verbose about error handling, but the current level is sufficient for a straightforward trigger operation.

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 documents all parameters. The description's Args section merely lists the parameter names without adding new meaning beyond what the schema already provides. It adds minimal value beyond grouping conf and logical_date as optional.

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 function ('Trigger a new DAG run') and expands on it ('Creates a new DAG run for the specified DAG'). This distinguishes it from sibling tools like list-dag-runs, get-dag-run, and pause-dag, which have different purposes.

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 that this tool is for triggering a new run, and notes that it requires the --allow-write flag. However, it does not explicitly compare with alternative tools or state when not to use it. The implied usage is strong, but explicit exclusions are absent.

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 transparency burden. It discloses the write nature (requires --allow-write flag), the state change (sets paused to false), and the return type (CallToolResult confirming). It does not mention idempotency or failure cases, but for a simple state toggle, this is adequate.

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

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

The description is well-structured with the purpose statement first, then behavior, flags, args, and returns. It is slightly redundant because the Args section duplicates schema descriptions, but it is not overly verbose and every sentence contributes context.

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 mutation tool with complete schema coverage and no output schema, the description covers the essential context: what it does, the permission requirement, and what it returns. It does not address edge cases, but those are not critical here.

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

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

Schema coverage is 100% and each parameter already has a description in the schema. The description's Args list essentially restates those descriptions, adding no further semantic meaning. The only extra is 'ctx', which is not in the schema but is likely MCP context.

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 clear verb+resource statement 'Unpause a DAG' and specifies the exact effect: setting paused status to false, allowing scheduled runs to resume. This distinguishes it from sibling tool pause-dag.

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 indicates when to use the tool: when you want to resume a paused DAG. It also mentions a prerequisite (requires --allow-write flag). However, it does not explicitly contrast with alternatives like pause-dag or trigger-dag-run, but the use case is 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?

With no annotations provided, the description carries the full burden of disclosing behavior. It states the operation is asynchronous, requires the --allow-write flag, and only provided parameters are updated. This gives the agent essential safety and execution context, though it stops short of describing side effects like potential downtime or environment restart.

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 a clear opening sentence, auth requirement, and a formatted Args list. The Args list is somewhat redundant with the schema, but the overall description is scannable and contains no filler. It earns its length by adding behavioral details.

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 9-parameter async mutation with no output schema, the description covers the main purpose, partial update behavior, async nature, auth requirement, and the return type. It could mention prerequisites like the environment existing or potential errors, but it is largely complete for an update 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?

All 9 parameters have full schema descriptions, so the baseline is 3. The description adds the crucial semantic that omitted parameters are left unchanged ('Only provided parameters will be updated'), which is essential for correct partial updates. This goes beyond what the schema states.

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 updates an existing MWAA environment. It also notes that only provided parameters are updated, which cleanly distinguishes it from create-environment, delete-environment, and get-environment. The verb 'update' plus the resource 'MWAA environment' 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 phrase 'Update an existing MWAA environment' and 'Only provided parameters will be updated' give clear context for when to use this tool: to modify an existing environment, not to create or delete one. However, it does not explicitly name alternatives like create-environment or get-environment, so it lacks explicit exclusions.

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