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

With no annotations, the description carries full burden. It only says 'summary' but does not disclose what the summary contains (e.g., counts, time ranges, aggregation), any side effects, or access requirements.

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?

Single sentence is concise and front-loaded with the action. However, it could be slightly more informative without being verbose.

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 name and many siblings, the description should clarify what the summary includes and how it differs. It is too minimal for adequate completeness.

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?

No parameters exist; schema coverage is 100%. The baseline of 4 is appropriate as the description adds no parameter info but is not needed.

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

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

The description states it provides a summary of event logs across all DAGs, which is a clear verb+resource. It distinguishes from siblings like 'list_event_logs' (detailed logs) and 'all_dag_import_summary' (import summaries), though not explicitly.

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. Does not specify exclusions, prerequisites, or when to prefer other tools like 'list_event_logs' for detailed logs.

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?

Since no annotations are provided, the description carries the full burden. It only states the purpose but does not disclose behavioral traits such as performance implications, authentication requirements, or whether the summary is real-time or cached.

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 sentence with no unnecessary words, perfectly 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?

Given the tool has no parameters and an output schema exists (though not detailed), the description adequately conveys the tool's role. However, a slightly richer description of what the summary includes could improve completeness.

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, so the baseline is 4. The description does not need to add parameter details since none exist.

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 provides a summary of import errors across all DAGs, distinguishing it from siblings like list_import_errors (which lists individual errors) and failed_dags (which focuses on failed DAG runs).

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 over alternatives. It does not mention context, prerequisites, or situations where another tool (e.g., list_import_errors) would 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?

No annotations are provided, so the description carries the full disclosure burden, and it discloses almost nothing: no permissions required, no duplicate-connection_id behavior, no failure modes. A mutation tool with zero annotation coverage and a one-line description leaves the agent guessing 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 single sentence is front-loaded and wastes no words, but it is under-specified rather than genuinely concise—the brevity comes from omitting information, not from tight editing. The redundant "[Tool Role]:" prefix contributes little.

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 output schema is present so return values need not be explained, and the parameter is fully documented in the schema. But for a write operation with no annotations, the description should still say something about preconditions (permissions, duplicate ids) and it does not.

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

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

Schema description coverage is 100% and the connection_data property already documents connection_id, conn_type, optional host/login/password/schema/port/extra, and the secret-store advice. The description adds nothing beyond the schema, so the baseline of 3 applies.

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

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

The description states a clear verb and resource ("Creates a new connection"), which separates it from list_connections/get_connection/update_connection by intent. However, it is essentially a restatement of the tool name and adds no distinguishing detail such as what a "connection" includes or when creation is preferred over update.

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 guidance on when to use this tool, no mention of prerequisites (permissions, existing connection_id collisions), and no reference to the sibling update_connection or get_connection tools. The agent must infer everything from the name alone.

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 provided, so the description carries the full burden. 'Shows' implies a read operation, but nothing states permission requirements, whether the calendar is computed vs stored, or behavior for missing DAGs. One sentence leaves most behavioral context undisclosed.

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?

Single front-loaded sentence with zero waste. It's efficient but arguably under-specified rather than maximally 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?

Output schema exists and all required params are documented in schema, so minimal gaps. However, with no annotations and only one description sentence, an agent lacks guidance on when to use it and interpret calendar 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 coverage is 100% and each parameter has a clear description (dag_id exact identifier, ISO 8601 inclusive bounds). The description adds nothing beyond the schema, so 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?

States a specific verb+resource: 'Shows DAG schedule and execution calendar.' Distinguishes it from siblings like list_dags or dag_graph, but doesn't name a sibling or clarify the boundary with dag_run_duration/dag_task_duration.

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 when-to-use guidance or alternatives mentioned. Only a hint that it's scoped to a date range; no indication when an agent should pick this over list_dags or dag_run_duration.

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 disclosure burden, yet it says nothing about read-only nature, permission requirements, size limits, or truncation for large DAG files. Only the bare retrieval action is stated.

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 front-loaded sentence with no filler. The only minor overhead is the '[Tool Role]:' prefix, which is boilerplate rather than 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?

An output schema exists, so return format need not be explained, and the single parameter is fully documented. However, with zero annotations and no behavioral notes, the definition is adequate but thin for a tool an agent may call on arbitrarily large DAGs.

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

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

Schema coverage is 100% and the schema already explains that dag_id is the exact identifier as returned by list_dags, not the display name. The description adds no further semantics beyond the schema, so the baseline 3 applies.

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

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

Uses a specific verb ('Retrieves') and resource ('source code for the specified DAG'), so the agent knows exactly what comes back. It does not differentiate from near-neighbors like get_dag or dag_graph, which likely return metadata/structure rather than source, leaving a small 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?

No guidance on when to pick this over get_dag or dag_graph, and no prerequisites or exclusions stated. The agent must infer from the name alone that this returns raw source text rather than parsed structure.

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 burden, and 'Retrieves' at least signals a read-only operation. It does not disclose anything about cost, size for large DAGs, permissions, or what 'graph structure' contains (nodes, edges, dependencies), though the presence of an output schema reduces the need to describe return values.

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 front-loaded sentence with no filler; the only redundancy is the '[Tool Role]:' label, which carries little information. Appropriately sized for a simple one-parameter read.

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 output schema and 100% parameter coverage mean the essentials are covered, but for a tool with many closely related siblings, the description leaves the agent without a selection criterion. Naming the alternative (get_dag for metadata, list_tasks for task list) would close the gap.

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

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

Schema coverage is 100% and the single parameter is well documented, including the important 'not its display name' caveat, so the baseline of 3 applies. The description adds nothing 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?

States a specific verb ('Retrieves') and resource ('task graph structure for the specified DAG'), which is meaningfully different from get_dag or list_tasks. It does not explicitly name or contrast those siblings, so the differentiation must be inferred.

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 statement of when to use this instead of get_dag, list_tasks, or dag_code, all of which appear in the sibling list and sound related. An agent has to guess whether it wants the graph topology or DAG metadata.

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 disclosure burden, yet it says nothing about read-only behavior, cost/latency (how many runs are scanned), or what "performance metrics" concretely includes. A single role label plus one clause is far below the bar for an unannotated analytical 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?

It is one short sentence with no wasted clauses, but the "[Tool Role]:" boilerplate prefix consumes words without conveying information, and the sentence is under-sized rather than efficient for its stakes.

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 described, but with zero annotations and only two sentences the definition leaves an agent without enough context for an analytics tool: nothing on what metrics are computed, the default window (limit=10 implies recency only), or how it differs from dag_task_duration.

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%: dag_id is documented as "Exact DAG identifier, as returned by list_dags; not its display name" and limit as the max number of recent runs. The description adds no parameter meaning beyond that, so the baseline 3 applies.

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

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

The description names a verb ("Analyzes") and a resource ("DAG run durations") plus a vague add-on ("performance metrics"). It does not distinguish this tool from the sibling dag_task_duration, so an agent cannot tell from the text alone whether to pick run-level vs task-level duration analysis.

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 when-to-use guidance, no prerequisites (e.g., that dag_id must come from list_dags), and no explicit routing to or from alternatives like dag_task_duration, dag_calendar, or running_dags. Usage must be inferred entirely from the name.

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 behavioral burden and does not meet it: it does not state read-only vs mutating nature, permission requirements, cost, or result size. Nothing is contradicted, but almost nothing beyond the name is 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?

A single short, front-loaded sentence with no waste, but it errs toward under-specification rather than conciseness. The '[Tool Role]' label adds no information an agent can act on.

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

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

For a two-parameter analysis tool with no annotations, one sentence is insufficient: what 'analysis' means (per-task durations? totals? comparisons?) is left undefined, and no usage context is given. The existing output schema helps with return-value shape, but the description still leaves the agent guessing about the tool's actual 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 coverage is 100% and both parameters are well documented in the schema, including the 'omitted selects latest run' default behavior, so the schema does the heavy lifting. The description adds no parameter meaning of its own, which is the baseline expectation here.

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

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

States a resource (task durations within a DAG run) and implies a read/compute operation, which does separate it from the sibling dag_run_duration (whole-run duration). But the verb 'analyzes' is vague — it never says whether this aggregates, compares, or ranks task durations — so the agent cannot tell precisely what the tool produces.

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 when-to-use guidance and no mention of alternatives, despite obvious siblings such as dag_run_duration, list_tasks, and list_task_instances_all that overlap in scope. The agent must infer from the name alone which of these to pick.

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, but it only says "Deletes". It does not state whether deletion is permanent or reversible, whether it cascades to dependent DAGs/tasks, or what permissions/authorization are required for a destructive Airflow connection 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?

It is a single short, front-loaded sentence with no filler, but its terseness reflects under-specification rather than efficient conciseness. The one sentence barely earns its place because it adds nothing beyond the tool name.

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 destructive mutation tool with no annotations, the description should at minimum note irreversibility, permissions, and effect on referenced objects; all are absent. An output schema exists, so return-value explanation is not required, but the behavioral gaps remain significant.

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 required parameter connection_id documented as an "Exact Airflow connection identifier". The description adds no further parameter meaning, but the baseline is 3 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 states a clear verb and resource ("Deletes a connection"), so an agent can tell what it does at a glance. However, it essentially restates the tool name and offers no differentiation from closely related siblings such as create_connection or update_connection.

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 guidance on when to use this tool versus the alternatives; the sibling set includes create_connection and update_connection, yet the description does not mention them or any preconditions. The agent must infer that this is the destructive counterpart to those tools.

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

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

No annotations provided, so description carries full burden. It only states it lists failed runs, omitting behavioral details like read-only nature, pagination, or definition of 'recently'. Minimal disclosure.

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?

Single sentence front-loaded with '[Tool Role]' prefix. Concise with no wasted words. Could be slightly more structured but effective.

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 zero parameters and existence of output schema, description adequately states purpose but lacks details on time frame, ordering, or behavior. It's acceptable but leaves ambiguity.

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?

No parameters exist; schema coverage is 100% (empty schema). Description adds value by scoping to 'recently failed DAG runs', which is meaning beyond the empty schema. Baseline 4 for 0 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 it 'Lists all recently failed DAG runs' – a specific verb and resource. It distinguishes from siblings like 'running_dags' and 'all_dag_event_summary' by focusing on failures. However, no title provided and 'recently' is vague.

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 'running_dags' or 'all_dag_event_summary'. Missing explicit 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?

No annotations provided, and the description offers no behavioral details beyond the action. No mention of side effects, safety, rate limits, or any other traits.

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 unnecessary words. It is appropriately sized for the tool's simplicity.

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 having an output schema, the description lacks context about what configuration is returned (e.g., all or specific sections). It does not guide the agent beyond the basic action.

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 zero parameters with 100% coverage, so no additional description is needed. Baseline for no parameters is 4.

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

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

Description states 'Retrieves Airflow configuration.' which clearly specifies the verb and resource. It is distinct from sibling tools like list_config_sections, but does not explicitly differentiate.

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. The description does not mention context, prerequisites, or relationships to other tools.

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

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

With no annotations provided, the description carries the full behavioral burden. The word 'Gets' implies a read-only retrieval and it states that all options in the section are returned, but it does not disclose permission requirements, behavior for unknown sections, or other operational traits.

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 wasted words. It immediately communicates the core operation and scope.

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 tool with full schema coverage and an output schema, the description is minimally adequate. However, in a crowded config-related sibling set, it is not complete enough to guide an agent on when this tool is the right choice versus get_config, list_config_sections, or search_config_options.

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

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

Schema description coverage is 100%, and the schema already documents section_name as an exact Airflow configuration section name with an example. The description adds no parameter semantics beyond what the schema provides, so the baseline 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 states a specific verb and resource: it 'Gets all options within a specific configuration section.' This is clearer than a tautology and lets an agent understand the basic operation. However, it does not explicitly distinguish this from nearby siblings such as get_config, list_config_sections, or search_config_options.

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. The description implies it is for retrieving options in a known section, but it does not mention siblings or exclusions, leaving the agent to infer selection logic from the name alone.

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 disclosure burden and does almost nothing with it: it does not say whether the read is safe, whether sensitive fields (e.g. passwords in the connection) are masked, what happens when the ID does not exist, or what permissions are needed.

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?

One short, front-loaded sentence with no waste; the '[Tool Role]:' prefix is mild boilerplate but harmless. It errs toward under-specification rather than verbosity.

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 and the sole parameter is documented, so the essentials for calling the tool are covered. Still missing is how an agent should obtain a valid connection_id (e.g. via list_connections) and the not-found 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 coverage is 100% and the single connection_id parameter is described as the 'Exact Airflow connection identifier', so the schema does the work. The description adds nothing about the parameter, so the baseline 3 applies.

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

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

States a specific verb ('Gets details') and resource ('a specific connection'), and the singular framing plus the required connection_id distinguishes it from the plural list_connections sibling. What the 'details' actually encompass is left unspecified, keeping it 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?

There is no explicit statement of when to use this versus list_connections or the create/update/delete_connection siblings; the distinction only exists implicitly in the tool name and the required ID parameter.

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 behavioral burden, yet it says nothing about permissions, error behavior (e.g., unknown dag_id), or read-only semantics. An output schema exists, so return values need not be explained, but the safety and failure profile is entirely absent.

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 short sentence with zero filler and the resource stated up front. It is appropriately sized, though it leans toward under-specification rather than tight 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?

For a one-parameter read tool with full schema coverage and an output schema, the essentials are present. However, with no annotations the description should have covered error cases or read-only behavior, which it omits.

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

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

Schema description coverage is 100% and the single dag_id parameter is already documented in the schema. The description's phrase 'specific DAG' adds no format, source, or lookup guidance beyond that, so the high-coverage baseline of 3 applies.

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

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

The description uses a specific verb ('Retrieves detailed information') and a clear resource ('a specific DAG'), so an agent can distinguish it from list_dags or get_dags_detailed_batch on get-vs-list grounds. It does not explicitly name those siblings, which keeps it from 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?

There is no statement of when to use this tool versus alternatives such as list_dags or get_dags_detailed_batch, and no prerequisites or exclusions are given. The agent must infer the choice from the name alone.

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. 'Retrieves' implies a read-only operation, and 'batch with latest run information' conveys useful scope, but the description does not explicitly state side-effect safety, pagination behavior, rate limits, or how the detailed output differs from simpler list tools. The output schema helps with return format, but usage behavior remains thin.

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 wasted text. The '[Tool Role]:' placeholder adds minor noise, and 'detailed information' is somewhat vague, but the structure is efficient.

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

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

The tool has seven optional parameters, full schema descriptions, and an output schema, so the description need not repeat parameter or return details. However, with no annotations and no sibling routing guidance, the one-sentence description is only minimally complete for a batch retrieval 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 all seven parameters are documented in the schema. The description does not add meaning beyond the schema for pagination, filters, or fetch_all behavior, so the baseline 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 states a specific verb and resource: retrieves detailed information for multiple DAGs in batch. It adds the scope of including latest run information, making the purpose clear. It does not explicitly distinguish this from siblings such as list_dags or get_dag, 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 gives no guidance on when to use this tool versus alternatives like list_dags, get_dag, running_dags, or failed_dags. There are no exclusions, prerequisites, or contextual recommendations for selecting this batch-detailed variant.

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 behavioral burden, yet it only says it 'gets details'. It does not state that this is a read-only operation, what happens on an invalid or v2-era URI, or any permission requirements. An output schema exists so return shape needn't be covered, but the mutation/safety profile remains undisclosed.

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 short sentence with the key scope distinction front-loaded; every element (including the v1/v2 note) earns its place. Minor filler in the '[Tool Role]:' prefix, but otherwise efficient.

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

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

For a one-parameter read tool with full schema coverage and an output schema, the description supplies the one non-obvious detail (v1 only vs Assets in v2). It is largely sufficient, with only the read-only/error behavior left implicit.

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

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

Schema coverage is 100% and the single parameter's description already documents the URI format and v1-only constraint. The tool description's version note reinforces but does not extend beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb (Gets) and resource (details of a specific dataset), which is clear and distinct from list_datasets. The parenthetical note that it is v1-only and v2 uses Assets helps separate it from other retrieval paths, though it doesn't explicitly contrast with siblings like get_dataset_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?

Usage is implied: fetch details for one dataset. The v1/v2 caveat gives a routing hint away from Assets-based workflows, but there is no explicit statement of when to prefer this over list_datasets or get_dataset_events, nor any prerequisite guidance.

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

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

No annotations are provided, so the description must carry behavioral context. It discloses the important v1-only limitation and points to Assets for v2, but it omits read-only confirmation, permissions, pagination behavior, and event types. This is more than nothing but not adequate 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?

It is a single, front-loaded sentence that communicates purpose and version constraint without filler. The '[Tool Role]' prefix is slightly mechanical but does not meaningfully hurt conciseness.

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 tool is simple, has a complete input schema, and has an output schema, so return values need not be explained. However, with no annotations and no sibling differentiation, the description is somewhat thin on operational context even for a simple read 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 all three parameters are already documented in the input schema. The description adds no parameter-level semantics beyond reiterating that the dataset URI is API-v1-only, making the baseline score 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 uses a specific verb and resource ('Gets events for a specific dataset') and adds a meaningful API-version constraint (v1 only). It does not distinguish the tool from the closely named sibling list_dataset_events or explain why both exist, so it stops 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 only explicit guidance is the v1-only constraint, which is useful but negative-scoped. There is no direct guidance on when to use this instead of get_dataset or list_dataset_events; the 'specific dataset' phrasing only implies scoping.

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 behavioral burden, yet it only says "Retrieves". It does not disclose that this is a read-only, non-mutating operation, nor what happens when the ID does not exist (empty result vs error). An output schema exists, so return values need no explanation, but the operational behavior is essentially undescribed.

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 front-loaded sentence with no filler and no redundancy. The only dead weight is the "[Tool Role]:" prefix, which conveys nothing to the agent.

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 get-by-ID tool with full schema coverage and an output schema, very little needs to be said. The remaining gap is sibling differentiation against list_event_logs, which is a genuine but modest omission.

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%: event_log_id is documented as a numeric identifier and is the only required parameter. The description adds nothing beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb and resource ("Retrieves a specific event log entry"), and the word "specific" vs the sibling list_event_logs implies single-record retrieval. It is clear what the tool does, but it never names the sibling it is distinguished from, which for a family with list_event_logs and all_dag_event_summary would have been easy to add.

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 when-to-use or when-not-to-use guidance and no alternative named. An agent must infer from the name alone that this is the single-record lookup to use after list_event_logs returns an ID.

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 for behavioral disclosure. It only states 'checks' but does not describe the nature of the health check, error conditions, or any side effects. The brevity leaves significant transparency 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 a single concise sentence with no redundancy. The '[Tool Role]:' prefix is somewhat redundant but does not detract significantly from conciseness.

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 is simple (no parameters, one action) and an output schema exists, the description is adequately complete. Adding typical response or error handling could increase completeness slightly, but it's sufficient for a health check.

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?

There are zero parameters, so the description does not need to add parameter information. Baseline score of 4 is appropriate as no additional semantic value is 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 clearly states the tool's purpose: 'Checks Airflow cluster health status.' The verb 'checks' and resource 'Airflow cluster health status' are specific and distinct from sibling tools like get_version or get_config.

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 (e.g., get_version for version info, get_config for config). The description lacks context for appropriate usage scenarios.

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 bears full disclosure burden. 'Retrieves' implies a safe read, and an output schema exists to cover the return shape, but the description says nothing about behavior when the ID does not exist or any permission requirements. For a simple read tool this is acceptable but thin.

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?

One short front-loaded sentence with no waste. The '[Tool Role]:' prefix is mild boilerplate, and the extreme brevity edges toward under-specification rather than optimal conciseness.

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 one fully documented parameter and an output schema covering return values, the description is nearly sufficient for calling the tool. However it omits sibling differentiation from list_import_errors and any not-found behavior, leaving clear 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% with a single required parameter already documented as a numeric identifier of a DAG import error. The description adds no meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (retrieves) and resource (a specific import error), and the word 'specific' implicitly contrasts with listing siblings. It stops short of naming list_import_errors or explaining what an import error record contains, but the core purpose is 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?

There is no explicit when-to-use guidance, no prerequisites, and no mention of the alternative sibling list_import_errors for browsing errors. The agent must infer from 'specific' that this requires a known ID.

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. "Gets details" implies a read-only retrieval and the output schema covers return values, but the description does not mention behavior when the pool is missing, permissions, or any other operational traits.

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 short sentence with the key information front-loaded and no wasted text. It is appropriately sized for a simple get-by-name tool.

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 operation with full schema coverage and an output schema, the description is nearly complete. It could improve by explicitly routing agents to list_pools when they do not already know the pool name.

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

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

Schema description coverage is 100%, and the schema already documents pool_name with an example, so the baseline is 3. The description adds only "specific pool" without additional meaning 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 states a clear verb and resource: "Gets details" for "a specific pool." It is distinguishable from the list-oriented sibling by "specific," but it does not explicitly name or differentiate against list_pools.

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 list_pools or other pool-related siblings. Usage is only implied by the required pool_name parameter and the word "specific."

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 and delivers almost nothing: it does not say whether the tool is read-only, whether the template is static or generated per request, or what invoking it changes. Only the word "Provides" weakly implies a non-mutating read.

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?

It is a single short sentence with no filler, but the bracketed "[Tool Role]:" prefix is meta-noise and the brevity comes at the cost of under-specification rather than 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?

An output schema exists, so return-value explanation is not required, but for a tool with zero annotations the description should still say what the template covers and how the optional selectors behave. As written, an agent cannot confidently predict 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 both mode (summary/detailed) and section are already documented in the schema. The description adds no extra meaning about accepted values or interactions between the two parameters, so baseline 3 applies.

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

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

The description states a verb+resource ("provides prompt template") and scopes it to "Airflow operations," which is more than a bare restatement of the name. However, it never explains what the template is for or how it differs from the many Airflow data-reading siblings, so it stays at vague-purpose level.

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 call this versus other tools, no mention of the optional mode/section selectors as a way to narrow the response, and no indication of whether this is a prerequisite step before other Airflow operations. The agent is left to infer everything.

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 behavioral burden, yet it only restates the name. It says nothing about read-only nature, error behavior for unknown providers, or what 'details' comprise.

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?

One short sentence, front-loaded with the action and resource, with no filler. It is efficient, though its brevity borders on under-specification.

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 no explanation, and the lone parameter is fully documented. However, for a lookup tool the absence of any failure-mode or discovery guidance leaves a modest gap.

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

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

Schema coverage is 100% and the single parameter already documents the exact package-name format with an example, so the description needs no additional parameter semantics. Baseline 3 applies.

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

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

States a specific verb (Gets details) and resource (a specific provider package), which separates it from list_providers by scope. It stops short of explicitly naming the sibling, so differentiation relies on inference.

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 implied — fetch details when you have an exact provider package name — but there is no explicit when-to-use, when-not-to-use, or pointer to list_providers for discovery.

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 doesn't state that this is a read-only operation, what 'details' comprises, whether it errors on missing instances, or authorization requirements. The only signal is the implicit read semantics of 'Gets'.

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 front-loaded sentence with zero filler. It is efficient, though borderline under-specified rather than richly informative.

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 and the input schema is fully documented, so the missing pieces are modest. Still, for a read tool with no annotations, a sentence on what 'details' covers and how it relates to the logs/extra-links siblings would make it 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% and each of the three parameters (dag_id, task_id, dag_run_id) has a clear description including the exactness/'as returned by list_dags' caveat. The description adds nothing beyond this, so baseline 3 applies.

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

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

States a specific verb ('Gets') and resource ('detailed information for a specific task instance'), which is clearer than a bare restatement of the name. Sibling tools like get_task_instance_logs and get_task_instance_extra_links are implicitly differentiated by the word 'details', but the description never names them explicitly.

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 vs. list_task_instances_all, list_task_instances_batch, get_task_instance_logs, or get_task_instance_extra_links. The agent must infer selection from tool names alone.

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 behavioral burden. 'Gets' implies a read-only call, but it never says what extra links actually are (e.g., operator-configured URLs to external systems), whether they can be empty, or what access is required.

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 short sentence that is front-loaded with the verb and resource, with no wasted clauses. The '[Tool Role]:' prefix is mild filler but harmless.

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, and the params are fully documented in the schema. Still, for a tool with zero annotations, one clause explaining what extra links are and that the call is read-only would close the remaining gap.

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

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

Schema description coverage is 100% and all three identifiers are well documented in the schema, so the baseline is 3. The description adds nothing about the parameters beyond what the schema already supplies.

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

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

States a verb and resource ('Gets extra links for a task instance'), which is specific enough to act on, but 'extra links' is a domain term left unexplained, and it does not differentiate itself from adjacent siblings like get_task_instance_details or get_task_instance_logs.

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 versus the other task-instance tools (details, logs, xcom entries). The agent must infer that this is the tool to call when it needs operator-defined external links.

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 behavioral burden. It does not disclose whether logs exist only for started/finished attempts, how try_number maps to retries, whether output is paginated or truncated, or any permission requirements — all relevant for a log-retrieval 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?

A single front-loaded sentence with no filler. The '[Tool Role]:' prefix is slightly stylized but the substance is efficient and immediately conveys the action and target.

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 and the input schema is fully documented, so return values and parameters need not be explained. Still, for a log tool with no annotations, the description leaves behavioral questions (retry semantics, log availability) unanswered, making it only minimally adequate.

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 four parameters including try_number's default are already documented in the schema. The description adds no extra semantics beyond 'specific task instance', so the baseline 3 applies.

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

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

States a specific verb ('Retrieves') and resource ('logs for a specific task instance'), which distinguishes it from siblings like get_task_instance_details and get_task_instance_extra_links. However, it does not explicitly name a sibling or state the boundary between logs and details.

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 gives no indication of when to use this tool versus get_task_instance_details or get_task_instance_extra_links, nor any prerequisite such as the task instance needing to have run. Usage must be inferred entirely from the tool name.

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, yet it says nothing about required permissions, behavior for unknown usernames, or whether roles/attributes are returned. 'Gets' implies a read, but that is the only behavioral signal in the text.

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?

One short sentence with the resource and scope stated immediately. The '[Tool Role]:' prefix adds no information but costs little.

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 and the parameter is fully documented, so the remaining gaps are modest. Still, for a lookup tool with no annotations, the description should at least say what happens when the user does not exist and how it relates to list_users.

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

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

Schema coverage is 100% and the schema already documents the single 'username' parameter including the exact-match and v1-only constraint. The description repeats rather than extends that information, so the baseline 3 applies.

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

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

States a specific verb and resource ('Gets details of a specific user') and adds a scope qualifier ('v1 API only'). It does not explicitly contrast with the sibling list_users, so it stops 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?

There is no guidance on when to use this versus list_users (to enumerate users) or why the v1-only restriction matters. The only hint is the parenthetical API version note, which implies a constraint rather than a selection rule.

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 behavioral burden. 'Gets' implies a read operation, but the description does not state what happens if the variable is missing, whether variables may contain sensitive values, or any permission requirements.

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 wasted elaboration. The '[Tool Role]:' prefix is minor metadata overhead but does not materially hurt readability.

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?

This is a simple one-parameter getter with full schema description coverage and an output schema, so the description is mostly complete for calling the tool. The main missing context is error behavior for nonexistent variables and any sensitivity handling, which are not covered elsewhere.

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

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

Schema coverage is 100%, and the schema already documents variable_key as the exact key of the Airflow variable. The description adds no additional parameter semantics beyond saying it retrieves a specific variable, so the baseline 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 gives a clear verb and resource: it gets the value of a specific variable. It does not explicitly contrast with the sibling list_variables, so an agent can infer but not be certain why to choose one over the other.

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 when-to-use guidance, no exclusions, and no mention of alternatives such as list_variables. The purpose implies it is used to retrieve a known variable, but the description does not guide the agent on when this is preferable.

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 provided, so description must stand alone. It implies a read operation but lacks detail on response structure or side effects. With output schema available, the gap is partially filled.

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?

Single sentence, front-loaded. The '[Tool Role]' prefix is unnecessary jargon but does not significantly harm clarity.

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?

Tool is simple with no parameters and an output schema. Description sufficiently states the purpose. Could mention output schema existence, but not required.

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?

No parameters exist, and schema coverage is 100%. Description adds no param info, which is acceptable as baseline for 0 parameters is 4.

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

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

Description clearly states the action (get) and resource (Airflow version information). However, it does not differentiate from siblings like get_health or get_config, which also retrieve system information.

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. Given many sibling tools, explicit context is missing.

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 behavioral burden, yet it says nothing about read-only nature, behavior when the key does not exist (error vs empty), or permission requirements. The presence of an output schema removes the need to explain return values, but the disclosure gap remains.

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 front-loaded sentence with zero waste, but it is under-specified rather than tight—brevity comes at the cost of any operational 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?

With a full output schema and 100% parameter description coverage, the structured data supplies most of what an agent needs to invoke the tool correctly. The missing piece is behavioral context, which no annotation covers.

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 each of the four identifiers documented in the schema itself. The description adds no additional semantics, so the baseline 3 applies.

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

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

The description states a specific verb and resource ("Gets a specific XCom entry"), which is clearly distinct from list_xcom_entries by the singular/plural naming. It does not explicitly call out the sibling relationship or scope, but an agent can infer the get-vs-list distinction.

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 guidance on when to use this tool versus list_xcom_entries, nor any prerequisites such as needing a completed task instance or existing key. The agent must infer usage entirely from the name.

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 does not disclose any behavioral traits such as auth requirements, performance characteristics, or whether the tool is read-only. With no annotations provided, the description should fill this gap but fails to do so.

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 that is concise and front-loaded. It efficiently communicates the tool's purpose without waste, though it could be slightly more detailed.

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 simplicity (0 parameters, output schema present), the description is minimally adequate. However, it does not mention the scope of sections (e.g., all sections or filtered), which could be improved. The output schema likely covers return details, so completeness is acceptable but not excellent.

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 schema description coverage is 100%, so the baseline is 4. The description adds no additional parameter semantics beyond what the schema provides, but none are needed.

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

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

The description clearly states the tool lists all configuration sections with a summary. The verb 'lists' and resource 'configuration sections' are specific, and it distinguishes from siblings like 'get_config_section' which gets details of a single section. However, it could be more precise about the format of the summary.

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 like 'search_config_options' or 'get_config'. There is no indication of prerequisites or context, leaving the agent without enough information to choose 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 of behavioral disclosure. 'Lists' implies a read-only operation, but it does not state whether authentication is required, whether pagination is automatic, or what happens with large result sets beyond the schema's limit/offset fields.

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 wasted text. The '[Tool Role]' prefix is slightly redundant but the core content is efficient.

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

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

An output schema exists, so return values need not be explained. However, with no annotations and many sibling tools, the description should provide more context about when to choose this tool and its read-only nature. It is adequate but leaves clear 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%, and both pagination parameters (limit, offset) are fully documented in the schema. The description adds no parameter details, so the baseline 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 states a specific verb and resource: 'Lists all connections in Airflow.' It is clear that this is a collection-listing operation for Airflow connections, though it does not explicitly differentiate itself from sibling tools like get_connection or create_connection.

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 such as get_connection for a single connection or create_connection for writes. Usage is only implied by the generic 'list all' phrasing.

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 behavioral burden. It discloses that the operation lists registered DAGs and supports pagination, and listing implies a safe read operation. However, it does not mention permissions, rate limits, or whether the listing is live versus cached.

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 with no wasted words. The tool role and core behavior 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?

For a simple list operation with full schema coverage and an output schema, the description is mostly complete: it states the resource, scope, and pagination behavior. The main gap is sibling differentiation, which is a usage-guidance concern rather than a missing core detail.

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 input schema already documents all five parameters clearly. The description only adds 'pagination support,' which is already covered by the limit/offset/fetch_all parameters, so it does not add meaningful semantic detail 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 names a specific verb and resource: 'Lists all DAGs registered in the Airflow cluster.' It also mentions pagination support, which clarifies scope. It does not explicitly differentiate this tool from siblings like running_dags, failed_dags, or get_dags_detailed_batch.

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 enumerating DAGs but gives no explicit when-to-use guidance. It does not mention when to prefer this over running_dags, failed_dags, get_dag, or get_dags_detailed_batch.

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; it does convey that this is a read/list operation and flags the API-version limitation. It says nothing about permissions, result ordering, or how events are scoped when dataset_uri is omitted.

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 front-loaded sentence that names the role and appends the version caveat parenthetically. There is no redundant or filler text.

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 and all parameters are documented in the schema, so return values and inputs need no explanation here. What is missing is the relationship to the near-identically-named get_dataset_events sibling and any note on default listing behavior when no dataset_uri filter is given.

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 each of the four parameters (limit, offset, dataset_uri, source_dag_id) is already documented in the schema, setting the baseline at 3. The description adds nothing about filtering behavior or defaults 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 gives a specific verb ('Lists'), a specific resource ('dataset events'), and a stated purpose ('data lineage tracking'). It is clear what the tool returns, but it does not differentiate itself from the sibling get_dataset_events, whose name suggests 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 v1-only caveat ('v2 uses Assets') tells the agent when the tool is applicable, which is a real usage constraint. However, there is no guidance on when to choose this over get_dataset_events, list_datasets, or all_dag_event_summary, leaving the agent to infer the boundary.

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, and it does disclose one meaningful trait: this only works against the v1 dataset API (v2 assets are not covered). It says nothing about read-only safety, whether results are paginated by default, or ordering — traits an agent would want before calling a list endpoint, though the limit/offset params hint at paging.

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 front-loaded sentence with the key constraint in parentheses; nothing is padded. The '[Tool Role]:' prefix is slightly redundant boilerplate but costs little.

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 and all three parameters are documented, so the essentials are covered. The remaining gap is that the version caveat is stated but not resolved — an agent is told v2 uses Assets yet not told what to call instead, which is the one thing it might still need.

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 limit, offset and uri_pattern each fully documented including defaults, so the schema does the work and baseline 3 applies. The description adds no extra semantics such as pattern syntax or matching behavior beyond what the schema already says.

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

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

States a specific verb and resource ('Lists all datasets in the Airflow system'), which clearly distinguishes it from get_dataset and list_dataset_events among the siblings. It stops short of naming a sibling or defining scope (e.g. whether all datasets or only those with events/URIs are returned), so it is clear but not fully differentiated.

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 by the verb 'lists' — an agent can infer this is the enumeration entry point before calling get_dataset. The parenthetical '(v1 API only - v2 uses Assets)' gives a useful environmental condition for when the tool applies, but there is no explicit when-not guidance or pointer to the sibling that replaces it on v2.

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 behavioral burden, yet it only implies a safe read operation via the verb "Lists". It says nothing about required permissions, result size, ordering, or whether the paginated scan is expensive — all relevant for a log-listing endpoint.

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?

It is a single short sentence with no filler and the purpose is front-loaded, but the brevity reflects under-specification rather than efficient packing of useful information. The '[Tool Role]:' prefix is boilerplate that consumes space without adding meaning.

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 needn't be explained, and all three parameters are documented in the schema. However, with zero annotations and many closely related siblings (get_event_log, all_dag_event_summary, list_dag_events), the definition leaves the agent without enough context to choose this tool confidently.

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 limit/offset pagination semantics and the dag_id 'exact DAG identifier, not its display name' caveat are already fully documented in the schema. The description adds nothing beyond it, which is acceptable at 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 sentence "Lists event logs from Airflow" is essentially a restatement of the tool name list_event_logs plus the product name. It gives a verb and resource but adds no scope information (what an event log contains, which events) and does not distinguish it from the sibling get_event_log or all_dag_event_summary.

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 when-to-use guidance at all — nothing says when to list logs versus calling get_event_log for a single record or all_dag_event_summary for aggregates. The agent must infer the routing decision entirely from tool names.

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 behavioral burden. It only states that the tool lists import errors and does not disclose read-only behavior, pagination semantics, permission requirements, or any other operational traits.

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 short sentence with no wasted words, but it is under-specified rather than effectively concise. It lacks front-loaded differentiating or usage information that would help an agent select it.

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, and the parameters are fully documented in the schema. However, the description does not distinguish this list tool from the sibling get_import_error or explain pagination behavior, leaving a clear gap for a simple retrieval 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 fully documents the limit and offset parameters. The description adds no parameter meaning beyond what the schema provides, which is the baseline expectation for high 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 states a specific verb and resource: 'Lists import errors in Airflow.' An agent can understand the basic operation, but it does not differentiate from sibling tools such as get_import_error or all_dag_import_summary.

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 given on when to use this tool versus alternatives like get_import_error or all_dag_import_summary. The description provides no context, exclusions, or selection criteria.

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 convey behavioral traits. It mentions the v1 API constraint but does not disclose whether the operation is read-only, requires authentication, or any side effects. The minimal description leaves important behavioral aspects unclear.

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 sentence that is concise and front-loaded with the core purpose. Every word is informative with no 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 the tool's simplicity (no parameters, output schema exists), the description provides the essential information. However, it could briefly mention that it returns a list of permission objects, though the output schema likely covers that. Overall, it is nearly 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?

There are zero parameters, and the schema coverage is 100% (empty). Per the baseline rule for zero-parameter tools, the description does not need to add parameter details. The description is adequate in this dimension.

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 'Lists' and the resource 'permissions', and specifies it is for the Airflow system v1 API. However, it does not explicitly differentiate from sibling list tools like list_roles or list_users, which could cause confusion.

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 vs alternatives. The description lacks context about prerequisites or when not to use this tool.

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

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

No annotations provided; description only states a simple read operation. Lacks details on performance, ordering, or error handling, but the operation is simple.

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?

Single, front-loaded sentence with clear role prefix; no extraneous 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?

Adequate for a simple list with output schema; could mention return type or limitations, but not required given minimal 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?

No parameters exist, and description adds value by stating 'all' indicates no filtering. Baseline score of 4 applies for zero-parameter tools.

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?

Description clearly states verb ('lists') and specific resource ('all installed plugins in the Airflow system'), distinguishing it from similar list tools like list_providers.

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 explicit guidance on when to use versus alternatives like list_providers or list_dags, though the action is straightforward for listing plugins.

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 disclosure burden. Beyond 'lists all', it says nothing about pagination behavior, ordering, result size, or required permissions for a tool with 2 paging 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?

A single, front-loaded sentence with zero waste. It is efficient, though the prefixed '[Tool Role]' tag adds no information an agent can act on.

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 and parameters are fully described in the schema, so the description needn't explain return values or paging. For a simple read-only list tool, the remaining gap (whether results are exhaustive or paged) is minor.

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 limit and offset documented including defaults, so baseline 3 applies. The description adds no additional pagination semantics beyond what the schema already 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?

States a specific verb ('Lists') and resource ('pools in Airflow') with an 'all' scope. It doesn't explicitly name the distinction from sibling get_pool, though the singular/plural naming makes the split fairly discoverable.

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 no when-to-use guidance, no mention of alternatives like get_pool for a single pool, and no note that no filters are supported. The agent must infer usage entirely from the name.

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. It indicates a safe read operation ('lists all provider packages'). However, it does not disclose any potential limitations, permissions needed, or whether the output is paginated. Minimal but 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?

Single sentence that is direct and contains no redundant information. Every word serves a 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?

The tool has an output schema, so description need not explain return format. With 0 parameters, the description adequately states what the tool does. Could mention that it returns a list but not necessary. Slightly lacking in context about usage scenarios.

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 zero parameters, so description adds no param details. Schema coverage is 100% (vacuous). Baseline is 4 for no parameters; description is clear but does not add extra meaning 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?

Description explicitly states 'Lists all provider packages installed in the Airflow system.' The verb 'list' combined with resource 'provider packages' and scope 'all' is specific and distinguishes it from 'get_provider' which likely retrieves a single provider.

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. The sibling 'get_provider' could be used for specific providers, but no differentiation is provided. The description does not mention any context for why one would choose this tool.

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

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

No annotations are provided, so the description carries the behavioral burden. It makes clear this is a read-style listing operation and adds the v1-only constraint, but it does not disclose authorization requirements, rate limits, or whether the result is paginated beyond the presence of limit/offset in 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 description is a single front-loaded sentence with no wasted text. The bracketed label is minor and does not obscure the core 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 simple list tool with an output schema and fully documented pagination parameters, the description is mostly sufficient. However, the absence of annotations and the lack of guidance on when to use this versus related list tools leave some contextual 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%, and both limit and offset are documented with defaults in the schema. The description adds no additional parameter semantics, so the schema does the heavy lifting and 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 states a specific verb and resource: it lists all roles in the Airflow system. It also scopes the tool to the v1 API only, making the purpose clear, though it does not explicitly distinguish itself from siblings like list_permissions or list_users.

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 only usage context is the 'v1 API only' constraint. The description gives no guidance on when to choose this tool over related sibling tools such as list_permissions, and no prerequisites or exclusions are stated.

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 supplied, so the description carries the full burden. It says nothing beyond "lists" — no note on default result volume, pagination semantics for limit/offset, ordering, permission requirements, or what happens when filters are omitted on a large Airflow instance.

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 front-loaded sentence with no filler, though it errs toward under-specification rather than tight economy. There is nothing to trim but also little that earns its place.

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

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

An output schema exists, so return values need not be explained, but for a 15-parameter read tool with zero annotations the description is far too thin. It never mentions pagination defaults, result caps, or the difference from the batch/detail 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 100% across all 15 parameters, including format hints like ISO 8601 and units in seconds, so the schema does the heavy lifting. The description adds no parameter meaning of its own, which is the baseline-3 case.

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

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

States a specific verb and resource: "Lists task instances." However, it offers no differentiation from close siblings like list_task_instances_batch or get_task_instance_details, so an agent still has to guess which entry point fits its case.

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 "comprehensive filtering options" hints at broad, filter-driven listing but gives no explicit when-to-use guidance, no exclusions, and no pointer to the batch or detail siblings. The agent must infer the routing decision entirely.

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 disclosure burden, and it states nothing about permissions, read-only nature, default ordering, or result limits beyond what the schema already documents. For a list tool with zero annotation coverage this is thin, though the low risk of a read operation softens the 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?

One sentence, front-loaded with the verb and resource, with no filler. The '[Tool Role]:' prefix is boilerplate that earns no place, which keeps it from 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?

An output schema exists so return values need not be explained, and the flat five-parameter schema is fully documented. However, with no annotations and no sibling differentiation, the agent lacks enough to confidently choose this over list_task_instances_all.

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

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

Schema description coverage is 100% and all five parameters are documented in-schema, so baseline is 3. The description names date and state filtering but adds no semantics beyond what the schema already says, such as how states are matched or the pagination interaction.

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 names a specific verb and resource ('Lists task instances') and adds the batch nature plus the supported filters (date and state). It is clear what the tool does, but it does not differentiate from the sibling list_task_instances_all, leaving ambiguity about when 'batch' matters.

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 when-to-use guidance and no mention of alternatives, even though list_task_instances_all is an obvious sibling. The filters hint at valid use cases but the agent must infer the routing decision itself.

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 supplied, so the description carries the full behavioral burden. 'Lists' implies a safe read operation, but the description says nothing about whether results are paginated, how they are ordered, or what happens for an unknown dag_id. It is adequate but thin for a zero-annotation 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?

A single short sentence with the action and scope front-loaded, and no wasted words. It is perhaps over-compressed rather than verbose, but structurally clean.

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 tool is simple: one required parameter, fully documented in the schema, and an output schema exists to explain return values. The description covers the essential scope, leaving only usage routing and pagination behavior unaddressed.

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

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

Schema description coverage is 100%, and the schema already explains that dag_id is the exact identifier returned by list_dags, not a display name. The description's phrase 'specified DAG' adds nothing beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource (lists tasks) and scopes it to a single DAG, which implicitly distinguishes it from the sibling list_dags that enumerates DAGs themselves. It does not explicitly name any sibling, 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?

There is no guidance on when to use this versus alternatives such as get_dag, dag_graph, or list_task_instances_all. The only hint is the scope phrase 'within the specified DAG', which is implicit at best.

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