MCP-Airflow-API

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.0.0
Disambiguation4/5
Most tools clearly target distinct resources and actions, such as list_dags, get_dag, and trigger_dag. However, a few pairs like list_task_instances_all vs list_task_instances_batch and list_dataset_events vs get_dataset_events have overlapping purposes that could confuse an agent.
Naming Consistency5/5
All 54 tools follow a consistent snake_case verb_noun pattern, such as get_user, list_plugins, trigger_dag, and pause_dag. Even longer names like get_dags_detailed_batch and list_task_instances_all maintain the same pattern, with no mixed naming conventions.
Tool Count1/5
With 54 tools, this is an extremely large tool set for a single server. The number far exceeds the typical well-scoped range of 3-15 tools, and while Airflow is complex, many tools are redundant or could be consolidated, making the surface overwhelming for an agent.
Completeness3/5
The tool set provides broad read coverage for most Airflow resources, including DAGs, task instances, connections, variables, and pools, plus core actions like triggering, pausing, and unpausing DAGs. However, there are significant gaps in mutation operations, such as creating or updating variables, pools, and users, and missing common task management like clearing or retrying task instances.
Average 3.1/5 across 54 of 54 tools scored. Lowest: 2.4/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
This repository includes a glama.json configuration file.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It simply states 'Creates a new connection' without mentioning side effects, idempotency, required permissions, error conditions, or what happens if the connection already exists. This is a significant gap for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, which is concise, but it is under-specified rather than appropriately sized. It lacks critical details about the parameter and behavior, so the brevity is a result of omission, not effective compression.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one complex parameter (an open object) and no annotations or schema descriptions, the description is incomplete. It does not explain what a connection is, what fields connection_data accepts, or any behavioral consequences. The output schema exists but does not reduce the need for input guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for the undocumented 'connection_data' parameter. It does not, leaving the agent without any explanation of what the parameter should contain, its format, or constraints. The parameter is an open object with additionalProperties true, making the absence of semantics particularly problematic.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('Creates') and a specific resource ('a new connection'), which distinguishes it from sibling tools like list_connections, get_connection, update_connection, and delete_connection. The verb-resource pair is unambiguous and informative.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, common use cases, or exclusions. Sibling tools like update_connection and delete_connection are not referenced, leaving the agent to infer usage 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.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears the full burden of disclosure. It simply states 'Deletes a connection' without mentioning whether the operation is permanent, requires special permissions, or affects dependent resources. This lack of side-effect information is a significant gap for a mutating operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short, but this is under-specification rather than effective conciseness. It lacks even basic contextual information expected for a delete tool, so it fails to earn its place as a complete description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity and the presence of an output schema, some return-value details are unnecessary, but the description still omits crucial context about the operation's effects, reversibility, and preconditions. The single sentence is insufficient for a deletion tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not explain the connection_id parameter beyond what the schema already provides (just a name and type). The description adds no value in clarifying parameter meaning, format, or constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the action ('Deletes') and the resource ('connection'), which clearly conveys the core purpose. It distinguishes itself from sibling tools like get_connection, create_connection, and update_connection by being the only deletion operation, though it does not explicitly state the scope or target type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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, prerequisites (e.g., existence of the connection), or situations where deletion might be inappropriate. The usage is implied only by the tool's name and action verb.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the full burden. It only states 'Gets', implying a read operation, but discloses no behavioral details such as return format, error handling, or scope. This is minimal transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely brief, which is concise, but it is under-specified for a tool with four parameters. It lacks any structured information beyond the one-liner, making it not 'appropriately sized'.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no annotations, no parameter descriptions, and no behavioral details, the description is incomplete. The output schema exists but is not referenced, and the tool's relationship to sibling get/list tools is not explained.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not elaborate on any of the four required parameters (dag_id, dag_run_id, task_id, xcom_key). The agent must rely solely on variable names, which may be ambiguous without additional context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Gets' and identifies the resource as 'a specific XCom entry', clearly distinguishing it from sibling list_xcom_entries which lists entries. This makes the purpose immediately clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No usage guidance is provided. The description does not mention when to use this tool versus alternatives like list_xcom_entries, nor any conditions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries full responsibility for behavioral disclosure. It only states that it lists task instances with filters, but does not disclose pagination, sorting, return format, or any 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no wasted words, making it easy to read. It is front-loaded with the main action (lists) and object (task instances).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex tool with 15 parameters and no annotations, this one-line description is severely incomplete. It lacks usage context, parameter details, and differentiation from sibling tools, making it insufficient for an agent to select and invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 15 parameters and 0% schema description coverage, the description must compensate by explaining parameter semantics. It merely says 'comprehensive filtering options,' adding no specific meaning beyond what parameter titles already provide.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it lists task instances and mentions comprehensive filtering, which aligns with the tool's name. However, it does not distinguish from the sibling tool list_task_instances_batch, which also lists task instances.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance is provided on when to use this tool versus alternatives like list_task_instances_batch or get_task_instance_details. The description only implies usage for listing with filters.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It merely states it 'gets' links, implying a read operation, but does not disclose any behavior such as permission requirements, error handling, or return format. No annotation contradiction exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one sentence, highly concise and front-loaded with the verb. The '[Tool Role]:' prefix is extraneous and adds no value, slightly reducing quality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and an output schema not shown, the description is incomplete. It doesn't define 'extra links', mention any use cases, or explain the relationship between the three required parameters. Sibling tools exist for related operations but no differentiation is provided.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description adds no parameter-specific meaning. The parameter names (dag_id, dag_run_id, task_id) are self-explanatory for Airflow users, but the description doesn't explicitly map them to the task instance identifier. This is a gap given the low coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Gets extra links for a task instance' uses a specific verb and resource, and it clearly differs from sibling tools like get_task_instance_details and get_task_instance_logs. However, 'extra links' is not explained, which could be ambiguous for users unfamiliar with Airflow's plugin link concept.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
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 alternatives. No mention of scenarios, prerequisites, or comparisons to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read operation but does not disclose auth requirements, error behavior, or any other side effects. The description adds minimal context beyond the tool name.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
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 front-loaded and avoids fluff, making it easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with three required parameters and an output schema, the description is too sparse. It lacks usage context, fails to distinguish from similar sibling tools, and provides no guidance on how the parameters relate. The output schema covers return values, but overall completeness is insufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for missing parameter explanations. It does not mention any parameter details, adding no value beyond the parameter names themselves (dag_id, dag_run_id, task_id).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool gets detailed information for a specific task instance, using a specific verb and resource. However, it does not distinguish this from sibling tools like get_task_instance_logs or list_task_instances_all, missing the opportunity to differentiate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. The description only states what it does without mentioning context, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 says 'lists import errors' without mentioning pagination behavior, ordering, or any other operational traits, leaving the agent without important context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no fluff, but the '[Tool Role]' prefix is unnecessary. It is appropriately short for a simple list tool, though it lacks content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is too minimal for the tool's complexity. With no annotations, an output schema present, and a list operation, the description should at least indicate the scope of import errors (e.g., all DAGs) and relationship to other error-related tools. This gap makes the tool hard to use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% for the two parameters (limit, offset). The description does not explain these parameters at all, failing to compensate for the lack of schema documentation. Their standard names provide some intrinsic meaning, but no additional semantic value is added.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists import errors in Airflow, using a specific verb and resource. It does not explicitly differentiate from sibling tools like get_import_error or all_dag_import_summary, but the plural 'list' and resource name provide adequate clarity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as get_import_error or all_dag_import_summary. The description gives no context about typical use cases or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It only mentions 'existing connection', implying existence is required, but omits details about behavior on missing connections, partial vs full updates, idempotency, or 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.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single clear sentence, but it is under-specified. It is appropriately short and front-loaded, yet lacks additional structure or context that would make it useful for an agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Although an output schema exists, the description is incomplete for a mutation tool. It omits usage guidance, parameter semantics, and behavioral details, leaving the agent without enough information to correctly invoke the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage for both parameters, and the description does not mention connection_id or connection_data. The structure of connection_data is completely unspecified, which is a critical gap for an update operation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Updates') and the resource ('existing connection'), distinguishing it from sibling CRUD tools like create_connection, delete_connection, and get_connection.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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, nor any prerequisites or context. The description only states the action without explaining scenarios that require an update versus create/delete.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description only states it 'Shows' something, implying a read-only operation. It does not disclose any other behavioral traits such as permissions, performance, or whether it includes manual runs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that is front-loaded and contains no filler. Every word contributes to the main point.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema and a simple parameter set, the description lacks usage guidelines and parameter semantics. An agent would need to infer too much, making the description insufficient for reliable selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not elaborate on dag_id, start_date, or end_date beyond the tool name and the phrase 'date range'. It does not specify date formats or clarify what 'schedule and execution calendar' includes.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Shows' and identifies the resource as 'DAG schedule and execution calendar', scoped by a date range. It distinguishes from sibling tools like list_dags or get_dag, though 'execution calendar' could be slightly ambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as list_dags or dag_graph. It does not mention prerequisites, exclusions, or specific use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 only implies a read operation through 'retrieves,' but does not disclose whether special permissions are required (source code may contain secrets), what the response format is (though an output schema exists), or any error behavior. It adds minimal value beyond the tool name.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The core sentence is concise and front-loaded, containing no redundant words. However, the '[Tool Role]:' prefix is unnecessary metadata that adds noise without conveying information. Overall, the description is efficient but could have used the space to add meaning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one parameter and an existing output schema, the description is bare minimum. It fails to clarify what 'source code' means (e.g., raw Python file vs. serialized representation), how it relates to sibling DAG tools, or any prerequisites. An agent cannot confidently decide when to invoke this tool over get_dag or dag_graph.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not compensate. 'Specified DAG' merely restates the parameter name 'dag_id' from the schema. It does not clarify what constitutes a valid dag_id, how to obtain it, or any format expectations, leaving the agent entirely dependent on the schema's minimal type info.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'retrieves' and identifies the resource as 'the source code for the specified DAG,' which clearly differentiates it from sibling tools like get_dag (likely DAG metadata) and dag_graph (graph structure). Though 'source code' could be more precise, 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.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention related tools like get_dag or list_dags, nor does it state any prerequisites or exclusion conditions. The agent is left to infer usage context from the tool name and schemas.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states a high-level purpose and does not mention whether the operation is read-only, what output format to expect, how the limit parameter affects results, or any error/permission considerations. This lack of detail leaves an agent uncertain about side effects and return structure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no redundancy. It front-loads the core purpose effectively. While it could include more detail, it is appropriately sized for a simple tool and does not waste words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has a simple two-parameter schema and an output schema, so the description need not explain return values. However, it lacks usage guidance and parameter semantics, and it does not clarify what specific performance metrics are analyzed. It is minimally viable but leaves gaps for an agent deciding when and how to use it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema coverage, the description should compensate by explaining parameters, but it does not explicitly clarify dag_id or limit. It implicitly identifies dag_id as the DAG to analyze but leaves limit completely unaddressed. The parameter names are somewhat self-explanatory, yet the description adds minimal value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool analyzes DAG run durations and performance metrics, using a specific verb ('Analyzes') and resource ('DAG run durations'). It distinguishes from sibling tools like dag_task_duration by focusing on DAG runs rather than individual tasks, though the phrase 'performance metrics' is somewhat generic.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus alternatives such as dag_task_duration. There is no mention of use cases, exclusions, or comparisons to sibling tools. The only implied usage comes from the tool name and purpose, but no direct recommendation is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description is the only source of behavioral transparency. It uses 'Retrieves,' implying read-only, but does not disclose permissions, error behavior, or side-effect safety. No additional behavioral traits beyond the basic getter are described.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, with a clear first sentence and standard Args/Returns structure. The Returns line ('Comprehensive DAG details') is somewhat vague but does not add excessive length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter getter with an output schema, the description provides the essential purpose and parameter. However, it lacks disambiguation from numerous sibling DAG tools and provides no context about read-only safety or when to choose this over alternatives.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The Args section repeats the parameter name and basic description ('The DAG ID to get details for'), which adds no meaning beyond the schema's type and title. Schema description coverage is 0%, and the description does not compensate with examples, formats, or constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Retrieves detailed information for a specific DAG,' using a specific verb and resource. It distinguishes from list_dags (list) and get_dags_detailed_batch (batch) by implying single DAG scope, though it does not explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like get_dags_detailed_batch or dag_graph. It only states what the tool does, leaving the agent to infer usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits, but it only states that details and latest run information are returned. It does not explain pagination (limit/offset/fetch_all), filter behavior, or any side effects/authorization expectations. 'Retrieves' implies read-only, but the lack of detail about batching and pagination leaves important behavior unexplained.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no unnecessary wording. It is concise and cleanly structured, though it sacrifices informative detail for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Even though an output schema exists, the description is incomplete for a 7-parameter batch tool. It lacks pagination semantics, filter usage, and relationships to sibling tools, making it insufficient for an agent to invoke the tool correctly with all optional parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description mentions no parameters. Given 0% schema description coverage, the description carries the full burden of explaining limit, offset, fetch_all, is_active, is_paused, id_contains, and name_contains, but it fails to add any meaning beyond their names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('Retrieves') and resource ('multiple DAGs in batch'), adding a key detail ('latest run information'). It distinguishes itself from siblings like get_dag (single DAG) and list_dags (summary listing) by emphasizing batch and detailed retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as list_dags or get_dag. The phrase 'in batch' describes the operation rather than indicating when to choose it, and no exclusions or alternative recommendations are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral transparency but only says it lists connections. It does not disclose pagination behavior, response format, required permissions, or whether results are limited by default, leaving key behavioral traits unexplained.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that is easy to read and wastes no words. However, it is so brief that it misses opportunities to include useful context in the same space.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a list tool with pagination parameters and an output schema, the description is minimal. It does not explain how limit and offset work, nor does it differentiate from the many sibling list tools, leaving the agent without essential usage details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has limit and offset with 0% description coverage, and the description does not explain their purpose or how they affect the result set. The description adds no meaning beyond the parameter names and defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists all connections in Airflow, using a specific verb ('Lists') and resource ('connections') that distinguishes it from related 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.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as get_connection, nor any exclusions or context. The description only restates the tool's function without offering usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility. It only says 'Lists event logs' with no disclosure of pagination behavior, filtering options, read-only nature, or any side effects. This falls short of revealing behavioral traits beyond the abstract.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence with no fluff or repetition. It is appropriately sized for a simple list operation, earning high marks for conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Even though an output schema exists, the description lacks essential context such as pagination, the meaning of the 'dag_id' filter, or the distinction from single-event retrieval. The tool is simple but the description is too sparse to be fully actionable for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description should compensate, but it provides no parameter information. The schema itself has clear names and defaults (limit, dag_id, offset), but the description adds no meaning, such as what filters are available or how pagination works.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource: 'Lists event logs from Airflow.' It clearly states the tool's function but does not differentiate it from sibling tools like 'get_event_log' or 'all_dag_event_summary', which could be confused for similar listing/fetching operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 alternatives. The description does not mention any context, exclusions, or typical use cases, leaving the agent without criteria for selecting this tool over its siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must carry full disclosure. It only states 'Lists task instances in batch with date and state filtering' without explaining what 'batch' entails, pagination behavior, limit/offset semantics, or any side effects. This lacks sufficient detail for an agent to anticipate tool behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with a role tag, entirely front-loaded, containing no filler or redundant information. Every word earns its place, achieving excellent conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
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 usage guidance, parameter semantics, and behavioral detail. With 5 parameters and no annotations, this minimal description is insufficient for an agent to confidently invoke the tool, especially given the presence of similar sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description only vaguely references 'date and state filtering' without explaining limit, offset, or the format of start_date_gte/start_date_lte. It adds minimal meaning beyond the parameter names themselves, failing to compensate for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource ('Lists task instances') and adds scope ('in batch with date and state filtering'), making the core purpose clear. However, it doesn't explicitly differentiate from the sibling tool list_task_instances_all, so it loses a point for lack of clear sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 alternatives like list_task_instances_all or get_task_instance_details. No exclusions, prerequisites, or contextual hints are provided, leaving the agent without direction on tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the burden of disclosing behavioral traits. It only says 'Lists' implying a read-only operation, but gives no detail on pagination, permissions, response behavior, or side effects. Minimal transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence with no waste, but it is under-specified given the tool has parameters and no other documentation. It lacks essential information, making it not appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
While an output schema exists, the description omits any context about pagination, usage, or parameter semantics. For a simple list tool, this is still incomplete because it provides no guidance on the limit/offset behavior or how this relates to other variable tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has two parameters (limit and offset) with defaults but no descriptions, and schema description coverage is 0%. The description does not mention these parameters at all, so it adds no meaning beyond the raw schema. The tool description fails to compensate for the lack of schema documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
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 'variables in Airflow', making it specific and distinct from sibling tools like get_variable or list_users. It clearly identifies what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you need all variables, but provides no explicit guidance on when to use this versus alternatives like get_variable, nor any exclusions or context. This is implied usage, not explicit guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It implies a read-only analysis but does not explicitly state whether it is non-mutating, require permissions, or describe the output. It also does not mention how dag_run_id affects behavior, leaving significant gaps in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, no-waste sentence, which is concise. However, it is overly terse and omits critical details, making it under-specified rather than efficiently concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
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 does not explain what the output contains or how to interpret it. It also lacks context on the significance of task durations and when to use this over other DAG analysis tools. The close sibling 'dag_run_duration' amplifies the need for more completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% coverage, so the description must compensate. It mentions 'within a DAG run' but does not explain the roles of dag_id or dag_run_id, nor the effect of leaving dag_run_id null. The names are self-descriptive, but the description adds minimal value beyond them.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Analyzes' and clearly identifies the resource as 'task durations within a DAG run.' This distinguishes it from the sibling tool 'dag_run_duration', which presumably analyzes DAG run durations as a whole, providing explicit differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. Given the similar sibling 'dag_run_duration', the description fails to mention any exclusions or preferred contexts, leaving the agent without usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'Retrieves a specific event log entry' without revealing expected behavior like error handling, 404 responses, or any side effects. This is nearly tautological and adds no behavioral insight.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no wasted words or redundant details. It is front-loaded with a clear action and resource, making it efficiently structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
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 is too sparse for a tool with no annotations. It lacks context about when to use this tool versus list_event_logs, and it does not mention any limitations or edge cases. For such a simple get-by-ID tool, more contextual guidance would be expected.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has a single parameter event_log_id with zero description coverage. The description does not explain the parameter beyond implying specificity, failing to compensate for the lack of schema documentation. It adds minimal semantic value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'retrieves' and the resource 'specific event log entry', distinguishing this from list-style siblings like list_event_logs by emphasizing specificity. It is unambiguous about what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as list_event_logs. There is no mention of prerequisites, exclusions, or context for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure, but it only says 'Retrieves a specific import error.' It does not disclose error handling (e.g., 404 if not found), permission requirements, or return format, so an agent is left without critical behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no unnecessary words. It is concise and to the point, though it could be expanded with useful details without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
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 is too minimal for a useful tool. It lacks context about how to obtain an import_error_id (e.g., via list_import_errors), what the response contains, or how to handle edge cases, making it incomplete for an agent to invoke it confidently.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not explain the import_error_id parameter beyond implying specificity. The parameter name is self-explanatory, but the description adds no value in clarifying its meaning, format, or how to obtain a valid ID.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Retrieves') and the resource ('a specific import error'), which distinguishes it from sibling tools like list_import_errors that handle multiple errors. The word 'specific' indicates singular lookup, aligning with the required import_error_id parameter.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no explicit guidance on when to use this tool versus alternatives. It does not mention that list_import_errors should be used to enumerate errors or that this tool is for fetching a single error by ID, leaving usage context entirely implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It implies a read-only operation via 'Gets' but does not mention permission requirements, error behavior, or whether the pool must exist.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. It efficiently communicates the core action and resource.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter getter with an output schema, the description is minimally adequate. However, it lacks usage context and behavioral caveats, leaving the agent to infer when this tool is appropriate relative to siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one required parameter with only a title and 0% description coverage. The description adds minimal context by referring to 'a specific pool,' but does not explain the expected format or how pool_name maps to the resource.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('Gets') and resource ('details for a specific pool'), distinguishing it from list-oriented siblings like list_pools. However, it does not explicitly contrast with alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 list_pools or other getter tools. There is no mention of prerequisites, typical scenarios, or exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure, but it only restates the tool's purpose. It does not mention try_number behavior, log format, access requirements, or behavior when no logs exist.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler, making it highly concise. However, it is so terse that it adds little beyond the tool name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 4-parameter tool with no annotations and no parameter explanations, the description is under-specified. Although an output schema exists, the description lacks usage context and does not address the optional try_number or its relationship to sibling task-instance tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not compensate. It vaguely implies identification of a task instance, but provides no meaning for dag_id, dag_run_id, task_id, or try_number beyond what the parameter names already suggest.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Retrieves') and clearly identifies the resource ('logs for a specific task instance'), which distinguishes it from sibling tools like get_task_instance_details or list_event_logs. It conveys exactly what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description offers no guidance on when to use this tool versus alternatives such as get_task_instance_details, list_event_logs, or get_xcom_entry. There are no usage scenarios, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It merely states 'lists all pools', which is misleading given the schema's limit parameter (default 20) implies paginated results rather than truly returning all pools in one call. It also omits any details about permissions, response structure, or side effects, leaving the agent with an incomplete behavioral model.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no extraneous information. It earns its place by directly communicating the core function. The '[Tool Role]' prefix is slightly redundant but does not harm conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema, the description need not restate return values, but it should explain pagination behavior and clarify the relationship to get_pool. It does neither. The minimalism leaves critical gaps for a tool with pagination parameters, making it barely adequate for an agent to select and invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description is expected to compensate by explaining parameter meaning. It does not mention limit or offset at all. The agent can infer defaults from the schema, but the description adds no semantic context, such as how pagination controls which pools are returned.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Lists all pools in Airflow' clearly states the verb (lists), the resource (pools), and the scope (all), distinguishing it from sibling tools like get_pool which retrieves a specific pool. This is a specific and unambiguous purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as get_pool. There is no mention of pagination, filtering, or circumstances where one would prefer this list operation over a targeted lookup. The context is implied by the name, but no explicit exclusions or alternatives are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the burden. It only says what the tool does, not how it behaves. It doesn't mention whether it's read-only, the return format, pagination, permissions, or any side effects. For a simple listing tool this is minimal but still lacks useful context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that adds value. It's not overly verbose, but it lacks any structure or additional sections. For such a simple tool, this is acceptable conciseness, though it could be slightly more informative.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the existence of an output schema, return values are covered, but the description is too sparse to be complete. It doesn't clarify what 'tasks' means in this context (likely task definitions) versus task instances, and it doesn't distinguish from similar list tools. The tool has one parameter and no annotations, so the description needs to provide more context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It mentions 'specified DAG', which maps to the dag_id parameter, giving it meaning. However, it doesn't add details about the parameter's format, constraints, or possible values beyond the schema's type.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Lists all tasks within the specified DAG.' It specifies a verb (lists) and resource (tasks in a DAG), which distinguishes it from list_dags (which lists DAGs). However, it does not explicitly differentiate from sibling tools like list_task_instances_all, 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.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention conditions, exclusions, or related tools. There is no 'when to use' or 'instead use X' context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It only states that it 'gets details' — a read operation — but does not disclose error behavior (e.g., what happens if provider_name doesn't exist), permissions needed, response format (though output schema exists), or any other behavioral traits. The description is too thin to give an agent confidence beyond the basic action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one concise sentence, front-loaded with the key action. It contains no filler or redundancy. However, it is so brief that it sacrifices useful context; it is appropriately sized for a simple getter but could include a bit more guidance without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a simple single-parameter getter with an output schema present, so the description doesn't need to explain return values. Yet it still leaves gaps: no information about what 'details' means, how provider_name maps to a package, or edge cases. The description is minimally adequate but lacks completeness for an agent that might need to decide whether to use this tool or a sibling.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one required parameter, provider_name, with no description in the schema (schema description coverage is 0%). The tool description does not mention this parameter at all, so it adds no meaning beyond the parameter name itself. The name 'provider_name' is somewhat self-explanatory, but the description fails to compensate for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb+resource pattern: 'Gets details of a specific provider package.' It clearly indicates a single-item retrieval, and the word 'specific' implicitly contrasts with list_providers. However, it does not explicitly name this sibling or differentiate further, 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.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool: when you need details of one specific provider package, as opposed to list_providers which lists providers. Yet there is no explicit guidance on alternative tools, prerequisites, or situations where another tool would be more appropriate. The usage context is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It only notes 'v1 API only' and does not mention pagination behavior (despite limit/offset), safety profile, or any side effects. This is insufficient for a list operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, front-loaded with the tool's role, and contains no unnecessary words. It is concise and well-structured for the simple purpose it serves.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
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 return values need not be described. However, the description omits important context like pagination behavior and the implications of 'v1 API only'. It is adequate as a minimum viable description but has clear gaps in completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, and the description does not explain the meaning or usage of the limit and offset parameters. Since the description must compensate for the lack of schema descriptions, it fails to provide any value beyond the raw parameter names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists all users in the Airflow system, with a version constraint ('v1 API only'). This distinguishes it from siblings like get_user (single user) and other list tools for different resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 get_user or other list tools. The description does not mention exclusions or preferred contexts, so the agent is left without direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that a summary is produced, without disclosing aggregation details, pagination, time range scope, auth requirements, or behavior with large DAG counts. The word 'summary' implies read-only, but that is not explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with minimal wasted words, and the key information is front-loaded. The only minor issue is the '[Tool Role]:' prefix, which is boilerplate and adds no semantic value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with an output schema, the description is minimally sufficient for selection but leaves ambiguity about what the summary actually contains (e.g., counts, status breakdowns, time range). The output schema may cover the return structure, but the selection would benefit from a note on when to request this aggregate view versus raw event logs.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there is no parameter burden and the schema coverage is trivially 100%. The description adds no parameter-level detail, but none is required for this tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Provides summary') and identifies the resource ('event logs across all DAGs'), which clearly distinguishes it from raw log list/detail tools like list_event_logs and get_event_log. However, it does not explicitly contrast with other summary tools such as all_dag_import_summary, so it lacks full sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It does not mention use cases, when the aggregate summary is preferred over raw event logs, or any relevant prerequisites or filters.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must convey behavioral traits. It indicates a read-only operation ('Gets') but does not mention error handling, permission requirements, or any side effects. The primary behavior is clear for a simple getter, but missing details prevent a higher score.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence with no extraneous words. The '[Tool Role]' prefix is a minor stylistic choice but does not harm conciseness or clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a simple tool with one parameter and an output schema, so the description covers the basic purpose. However, it lacks sibling differentiation and usage context, which is important given the large set of related config tools. It is minimally viable but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one parameter with 0% description coverage. The description's phrase 'specific configuration section' adds minimal meaning beyond the schema's title 'Section Name', and it fails to provide examples, allowed values, or format expectations for section_name.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('Gets all options') on a specific resource ('a specific configuration section'). It implicitly distinguishes itself from sibling tools like list_config_sections or search_config_options, though it doesn't explicitly name them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as get_config or search_config_options. The description is a bare functional statement without context on prerequisites, typical use cases, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It implies a read-only operation by saying 'Lists', and the lineage tracking context adds some clarity. However, it does not disclose pagination behavior, response structure (though an output schema exists), or any limitations beyond the v1 restriction. This is adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that efficiently states the tool's role. It includes a purposeful API version note. It is concise with no wasted words, though it could have expanded on parameters without becoming bloated.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has four optional parameters and an output schema, but the description leaves gaps. It does not explain how filtering works via 'dataset_uri' or 'source_dag_id', nor does it clarify the difference from the sibling 'get_dataset_events'. Given the moderate complexity and the existence of a seemingly similar tool, the description is incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description does not mention any parameters. Parameter names like 'limit' and 'offset' are somewhat self-explanatory, but the description adds no value in explaining format, meaning, or relationships among parameters. It fails to compensate for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it lists dataset events for data lineage tracking, which is a specific verb and resource. It also notes the v1 API limitation, providing some distinction from v2. However, it does not differentiate from the sibling tool 'get_dataset_events', 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.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives a clear use case (data lineage tracking) and explicitly warns that v2 uses Assets, indicating a when-not-to-use condition. It lacks reference to the sibling 'get_dataset_events', but the API version guidance is useful.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not explain what 'entries' includes (keys, values, both), pagination behavior, ordering, or any side effects. The one-line description adds minimal context beyond the tool's name.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence with no unnecessary words. It front-loads the core purpose ('Lists XCom entries') and includes a scoping qualifier. This is appropriately concise for a tool with a straightforward purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having a 5-parameter schema and no annotations, the description provides only a high-level purpose. It lacks usage context, parameter explanation, and behavioral details. While an output schema exists (reducing need to explain return values), the description still feels incomplete for an agent to select and invoke the tool confidently.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It does not explain the role of dag_id, dag_run_id, task_id, limit, or offset. The phrase 'for a specific task instance' indirectly hints at the required parameters, but no explicit parameter semantics are provided, leaving pagination and identification details unclear.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool 'Lists XCom entries for a specific task instance.' The verb 'Lists' is specific, and the resource 'XCom entries' with qualifier 'for a specific task instance' distinguishes it from sibling tools like get_xcom_entry (singular) and other list tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus alternatives like get_xcom_entry. It does not mention exclusions, trade-offs, or specific use cases beyond the basic task-instance scoping. The usage context is only implied, not stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It only states the basic function without disclosing important behavioral traits like whether search is case-sensitive, partial/fuzzy matching, returns multiple matches, or any special output format. This is a notable gap for a search tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence. It is front-loaded with the role and contains no extraneous information. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter) and the presence of an output schema, the description covers the basics. However, it omits usage context relative to sibling tools and search behavior details, making it only moderately complete for an agent deciding when and how to invoke it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% coverage (no parameter description), but the description mentions 'matching a term,' which directly indicates that 'search_term' is the term to match. This adds meaning beyond the schema's title, though it lacks details such as whether wildcards are supported or how matching is performed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states an action ('Searches for configuration options') and a target ('configuration options matching a term'), which is specific and understandable. However, it does not differentiate this tool from sibling config-related tools like list_config_sections or get_config, so it is not a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance about when to use this tool versus alternatives such as get_config or list_config_sections. The description only states what it does, leaving the agent to infer when this search functionality is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since no annotations are provided, the description bears full responsibility for disclosing side effects. It merely states the action without noting asynchronous behavior, permission requirements, failure modes, or whether the trigger is a mutation. This is insufficient for a trigger tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no redundancy. Front-loaded with a role label, it efficiently communicates the core function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and minimal description, the tool is underspecified. The output schema exists but the description alone does not clarify what happens after triggering (e.g., returns a run ID) or how to confirm success.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must compensate. It only relates dag_id to 'specified Airflow DAG' but doesn't explain format, valid values, or behavior if the DAG doesn't exist. Minimal added meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('Triggers') and resource ('a new DAG run') for a specified Airflow DAG. It unambiguously distinguishes this from sibling tools like get_dag or pause_dag, which don't trigger runs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool, when not to, or how it compares to alternatives. It only states the tool role without context, prerequisites, or references to other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. As a mutation operation, it does not mention permissions, idempotency, or side effects, leaving the agent without critical context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence. However, the '[Tool Role]' prefix is a template artifact that adds no value, slightly reducing efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter mutation tool, the description is minimally adequate. However, missing usage guidelines and behavioral details make it incomplete for an agent to invoke confidently without additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, and the tool description adds no information about the dag_id parameter, such as format or acceptable values. The parameter name is self-explanatory only to users familiar with Airflow.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool unpauses a specified Airflow DAG, with a specific verb and resource. It naturally distinguishes itself from sibling tools like pause_dag and trigger_dag by its opposite action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as pause_dag or trigger_dag. The usage is only implied from the name and description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that it provides a summary, without detailing whether it aggregates across all DAGs, how the summary is structured, or whether it is a read-only operation. The lack of detail about the summary's nature makes it difficult for an agent to predict the tool's exact behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no unnecessary words. The '[Tool Role]' prefix is a minor label but does not detract from the conciseness. It is appropriately sized and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that the tool has zero parameters and an output schema exists, the description is mostly adequate for basic invocation. However, it does not clarify how the summary differs from list_import_errors or whether it is a high-level aggregate, which reduces completeness for an agent making a selection decision.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there is nothing for the description to document beyond what the schema already conveys. The baseline for a zero-parameter tool is 4, and the description does not need to add parameter-specific semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states it provides a summary of import errors across all DAGs, which is a specific verb+resource combination. It distinguishes itself from sibling tools like list_import_errors (which lists errors) and all_dag_event_summary (which summarizes events), though the term 'summary' could be more explicit about whether it aggregates counts or lists error categories.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as list_import_errors or all_dag_event_summary. It does not mention any exclusions, prerequisites, or situations where another tool 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.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. The verb 'retrieves' implies a read-only operation, but no details are provided about auth requirements, error behavior, pagination, or what exactly the task graph contains. The description adds minimal beyond the tool name.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence and is easy to parse. However, the prefix '[Tool Role]:' is unnecessary filler that adds no meaningful information, slightly reducing efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter retrieval tool with an output schema available, the description is mostly adequate. It states the core purpose, and the output schema likely documents the return shape. However, it could be improved by mentioning what 'task graph structure' includes or how it relates to sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage for the only parameter dag_id. The description's phrase 'specified DAG' loosely maps to dag_id but does not explain format, constraints, or how the ID is used to locate the graph. The parameter name is self-explanatory to some extent, but the description fails to compensate for the missing schema documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool 'Retrieves task graph structure for the specified DAG,' using a specific verb and resource. It distinguishes this tool from siblings like get_dag and list_tasks by focusing on the graph structure rather than general DAG details or task listing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus alternatives such as get_dag, list_tasks, or dag_code. There are no prerequisites, exclusions, or suggested alternatives, leaving the agent without clear selection criteria beyond the tool's name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It only states 'Retrieves Airflow configuration' and does not mention safety, permissions, response behavior, or any side effects. The verb implies a read operation, but no explicit disclosure is given.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that immediately conveys the core purpose. It contains no filler or repetition, earning its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple no-parameter tool with an output schema, the description states the basic function. However, it is ambiguous whether it returns the entire configuration or just a subset, and it does not distinguish from config-related sibling tools, leaving some contextual gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. The input schema is empty and description coverage is trivially 100%, leaving no parameter semantics to explain.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves Airflow configuration, with a specific verb and resource. However, it does not differentiate from sibling tools like get_config_section or list_config_sections, which also deal with configuration, 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.
Usage Guidelines2/5
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. The description only states what it does, with no mention of scenarios, exclusions, or sibling alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action and version scope, but does not mention whether this is a safe read operation, any authentication requirements, pagination behavior despite limit/offset parameters, or error conditions. This is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. Every phrase contributes meaning, including the version constraint. It is appropriately concise for the limited information it provides.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 3 parameters with 0% schema coverage and no annotations, so the description needs to supply more context. It covers purpose and version but omits parameter semantics and behavioral traits. The presence of an output schema reduces the need to explain return values, but other gaps remain, making it minimally viable at best (like the 'update_drive' calibration).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for parameter understanding. It implies dataset_uri is the identifier ('a specific dataset'), but does not explain the role of limit and offset, their defaults, or how they interact. The description adds minimal value beyond the parameter names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the action ('Gets events') and resource ('a specific dataset'), which is specific and distinct from sibling tools like get_dataset or list_dataset_events. The v1/v2 note adds scoping but does not explicitly contrast with sibling tool names, so it misses full sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear usage context: 'v1 API only - v2 uses Assets.' This tells when to use (v1) and when not (v2, use Assets instead), serving as an exclusion and alternative. However, it does not name specific sibling tools or elaborate on general conditions for use, so it's not a full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It only states the core action and the API version constraint. It does not mention pagination (though limit/offset exist), filtering capabilities, sort order, or any side effects. The v1/v2 nuance is useful but insufficient for a transparent view of behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the tool role and includes a crucial API version constraint. It is concise with no fluff, every word adds value, and it is appropriately scoped for a list tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Although an output schema exists, which reduces the need to describe return values, the description omits any explanation of the pagination and filter parameters. With three optional parameters and no parameter descriptions, the description is incomplete for an agent trying to use the tool effectively. The API version note adds some context but cannot offset the missing parameter semantics.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description does not mention any of the three parameters (limit, offset, uri_pattern). The agent gets no guidance on what uri_pattern filters, how limit/offset affect results, or their syntax. The description fails to compensate for the complete lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Lists all datasets in the Airflow system'. It distinguishes itself from siblings like 'get_dataset' (specific dataset) and 'list_dataset_events' (events) by focusing on listing all datasets. The added 'v1 API only - v2 uses Assets' note further differentiates it from v2 asset-related tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context on when to use this tool: only for Airflow v1, explicitly excluding v2. It does not name alternative tools for v2, but the exclusion is direct and helps the agent decide between versions. This is more than implied usage but lacks explicit alternative recommendations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It only says 'Lists', implying a read-only operation, but does not disclose permissions, side effects, or output behavior beyond the summary. No additional context is added.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, extremely concise and easy to parse. The '[Tool Role]:' prefix is slightly odd but harmless. It earns a high score for brevity, though it lacks any extra detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with no parameters and an output schema, so the minimal description might be adequate. However, the presence of several sibling config tools means usage context would be beneficial. It covers the basic action but misses situational guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline of 4 is appropriate. The description adds no parameter details, but nothing is needed since there are no parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Lists') and the resource ('all configuration sections'), with a note about the summary output. This distinguishes it from sibling tools like get_config_section (singular) and get_config (whole config).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as get_config or search_config_options. The description simply states what it does without indicating context, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the 'v1 API only' constraint and implies a read-only list operation, which is useful. However, it omits any details about pagination behavior or potential side effects, though for a list operation this is a minor gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that front-loads the tool's purpose and scope. Every word earns its place, with no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
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, the description is minimally complete. However, it leaves the pagination behavior implicit, and the 'all roles' wording in conflict with the limit/offset parameters creates ambiguity. It could benefit from clarifying that the list is paginated.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description does not explain the limit and offset parameters or how pagination works. The phrase 'Lists all roles' could mislead an agent into expecting no pagination, even though the schema has a default limit of 20. The description adds no value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool lists all roles in the Airflow system along with a v1 API scope. This is a specific verb+resource with a clear boundary, distinguishing it from other list tools like list_permissions or list_plugins.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 alternatives. The description only states what it does without providing decision criteria or mentioning any related tools that might be preferable in certain contexts.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits but only says 'Checks,' which implies read-only safety. It does not elaborate on what constitutes health status, potential side effects, or any operational nuances, offering minimal transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, short sentence that front-loads the action and resource. It contains no filler or redundant phrasing, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool's simplicity (no parameters) and the presence of an output schema cover return value details. However, the description lacks usage context and deeper behavioral information, making it minimally complete but not fully informative for an agent deciding when and how to invoke it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and an empty input schema, so the baseline is 4. The description need not add parameter-level detail, and it does not attempt to do so, which is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Checks' and clearly identifies the resource 'Airflow cluster health status,' which distinguishes it from sibling tools focused on other resources like DAGs or users. Despite its brevity, it fully conveys the tool's function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 alternatives. The description only states what it does, with no mention of scenarios, prerequisites, or exclusions, leaving the agent to infer appropriate usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the burden of behavioral disclosure. It mentions the 'v1 API only' version constraint, which is useful, and 'Gets' implies a read-only operation. However, it does not specify permissions, error conditions, or what happens if the user does not exist.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that conveys the tool's role without any wasted words. The '[Tool Role]:' prefix is a minor stylistic choice but does not harm clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the low parameter coverage, lack of annotations, and minimal description, the tool is under-specified. There is no guidance on when to use it, no mention of behavioral nuances beyond the version, and no clarification of what 'details' includes. The presence of an output schema partially mitigates return-value documentation, but overall completeness is lacking.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one parameter ('username') with 0% description coverage. The description does not explain the parameter's meaning or format beyond the schema, only that it targets a 'specific user'. Since coverage is low, the description should compensate, but it does not.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb ('Gets') and resource ('details of a specific user'), which distinguishes it from sibling tools like list_users (list vs. single) and get_provider (different resource). The 'v1 API only' qualifier adds specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'specific user' implies this tool is for retrieving a single user's details rather than listing all users, but there is no explicit guidance on when to use it over alternatives (e.g., 'use list_users for all users'). No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 disclosing behavioral traits. The description only says 'Gets the value,' which implies a read operation but does not explicitly state that it is non-mutating, does not disclose error behavior (e.g., what happens if the variable does not exist), or mention any auth requirements. This is insufficient for a tool with no annotation support.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description consists of a single sentence with no fluff. It is appropriately concise for a simple getter tool. Every word serves a purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with a single parameter and an output schema, so the description does not need to explain return values in detail. However, the description omits any usage context (e.g., when to use this vs. list_variables), error semantics, or side-effect guarantees. While the schema covers the parameter, the lack of behavioral context makes it minimally complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one parameter, variable_key, which is self-explanatory. The description adds minimal context by saying 'specific variable,' indicating that variable_key identifies the variable. While schema description coverage is 0%, the parameter is simple and well-named, so the description partially compensates but adds little information beyond the schema itself.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Gets the value of a specific variable.' It specifies a verb ('Gets') and a resource ('variable'), and the qualifier 'specific' distinguishes it from listing tools like list_variables. The purpose is unambiguous and differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit usage guidance or alternatives are provided. The phrase 'specific variable' implies that the tool is used when you know the variable key, which gives some context, but it does not explicitly state when to use it vs. list_variables or other tools. There is no mention of exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention whether the tool is read-only, has side effects, requires permissions, or handles invalid inputs. For a tool that returns a template, some transparency about safety or error behavior would be expected; the description offers none beyond the output description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is structured with sections for role, args, and returns, making it scannable. It is concise, but there is slight redundancy with 'comprehensive' appearing twice. Overall, every sentence contributes to understanding, and it avoids unnecessary filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description provides basic purpose, parameter explanations, and return summary, but lacks details such as available section names, behavior for invalid modes/sections, or interaction with other tools. Given the tool's simplicity and the presence of an output schema (not shown to the agent), it is adequate but has clear gaps in edge-case handling and operational specifics.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains both parameters: 'section' as 'Optional section name to get specific part of template' and 'mode' with explicit allowed values (summary/detailed) to control verbosity. This adds meaningful guidance beyond the raw schema, though it does not enumerate available sections or default behavior details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool provides a 'comprehensive prompt template for LLM interactions with Airflow operations,' using a specific verb+resource structure. This distinguishes it from all sibling tools, none of which mention prompt templates. The purpose is unambiguous and directly aligned with the tool name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool ('for optimal LLM guidance' in the Returns line) but does not explicitly state usage scenarios, prerequisites, or exclusions. There are no alternative prompt-template tools among siblings, so differentiation is not needed, but the guidance is only implied, not directly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It says 'Lists' which implies a read-only action, but it does not mention authorization requirements, pagination behavior, response format, or any potential side effects. For a system-level permission listing, an agent would benefit from knowing if admin privileges are required or if the API is deprecated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is direct and front-loaded with the action. However, the '[Tool Role]:' prefix is redundant and adds no informational value, slightly detracting from conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (zero params, output schema exists), the description is a minimal but viable starting point. It covers what the tool lists and the API version, but it omits any mention of authentication or the read-only nature, which are relevant for a permissions-related tool. The output schema probably describes return values, so that is not required, but additional context about access control would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema is empty and the description explicitly says 'all permissions', confirming no filters. With 0 parameters, the schema already provides complete coverage, and the description reinforces the unqualified scope. No additional parameter semantics are needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
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 'all permissions available in the Airflow system', along with an explicit version constraint '(v1 API only)'. This distinguishes it from sibling list tools like list_roles and list_plugins, which target different objects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage: use this tool to list permissions. However, it does not explicitly state when to use it versus alternatives, nor does it provide any exclusion criteria. The 'v1 API only' note gives some context but doesn't name alternative tools for v2 or other scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It states the core behavior (listing failed runs) and the 'recently' filter, implying a read operation. However, it does not define the time window, mention limits, or explicitly confirm read-only semantics. It adds moderate context but leaves key details undefined.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. It is immediately clear and efficiently communicates the tool's purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple, has no parameters, and an output schema exists, so return structure is covered. However, the term 'recently' is ambiguous and not defined, leaving the time window unclear. An agent may not know whether this returns the last hour, day, or all failed runs ever. This gap makes it adequate but incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, and the schema reflects this with an empty object. The description correctly implies no input is needed. Baseline 4 applies since there are no parameters to describe.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Lists all recently failed DAG runs in the Airflow cluster.' It uses a specific verb ('Lists') and resource ('failed DAG runs'), and the 'recently' qualifier plus cluster scope help distinguish it from siblings like running_dags or list_dags.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. The description does not mention other tools, prerequisites, or exclusions. An agent would have to infer from the name that this is for failed runs, but no explicit usage context is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the key behavioral effect (prevents scheduling new runs), which implies existing runs are not stopped, but it omits other details such as reversibility, idempotency, or 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is front-loaded with the verb and resource, contains zero waste, and efficiently states the core effect.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no nested objects, and an existing output schema), the description adequately covers the action and effect. Minor missing context about usage guidelines prevents a higher score, but the core purpose is well captured.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter 'dag_id' has 0% schema description coverage, and the description only vaguely references 'the specified Airflow DAG' without explicitly defining the parameter, its format, or how to obtain it. This does not compensate for the lack of schema detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Pauses') and resource ('Airflow DAG'), and the parenthetical 'prevents scheduling new runs' clarifies the action's effect. It clearly distinguishes from the sibling tool 'unpause_dag' by direction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by noting it prevents scheduling, but it does not explicitly state when to use this tool versus alternatives like 'unpause_dag' or 'trigger_dag', nor does it mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states a read operation ('gets details') but does not disclose error behavior, permission requirements, or whether the tool is non-destructive beyond the verb itself. The simplicity of the operation mitigates the lack of detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence of eight words, effectively front-loaded with the verb 'Gets'. No redundant content or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple getter with one parameter and an output schema, the description provides the essential purpose. It lacks context about error handling or when to use sibling tools, but the tool's straightforward nature makes this acceptable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one parameter (connection_id) with 0% description coverage. The description's 'specific connection' implies that connection_id identifies the target, but it adds little beyond the schema's 'Connection Id' title. For a single simple parameter, this is minimal but adequate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Gets details for a specific connection,' which clearly identifies the action (gets) and resource (connection details). It distinguishes from siblings like list_connections, which lists all connections, and create/update/delete tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used when a specific connection ID is known, but it does not explicitly state when to use it versus alternatives like list_connections. No exclusions or alternative tool mentions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. The verb 'gets' implies a read-only operation, but the description does not explicitly state that it is non-mutating, idempotent, or requires no special permissions. The behavior is simple enough that the description is adequate, but it lacks explicit safety disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no redundancy. The information is front-loaded, and every word contributes to meaning. The optional '[Tool Role]' prefix does not detract from clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the tool (no params, output schema exists), the description is sufficient to understand what it does. The output schema covers return value details, and no critical context is missing. The only minor gap is the lack of guidance on when to call it, which is more of a usage guideline issue.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema is empty. The baseline score for 0 parameters is 4, and the description adds nothing needed since there are no parameters to explain. The description correctly communicates the lack of required inputs implicitly.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Gets') and the resource ('Airflow version information'), making it specific and distinguishable from sibling getter tools. It directly answers what the tool does without ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, nor any context or exclusions. While the tool is simple, the complete absence of usage context reduces its value for an AI agent deciding between many sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It clearly indicates a read-only enumeration operation, but does not explicitly mention side effects, permissions, or other behavioral traits. The verb 'Lists' is sufficient for a simple read operation, but not much is added beyond that.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, using one short sentence with no filler. The 'Tool Role' prefix is slightly unnecessary but does not detract from the clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of a zero-parameter, no-annotation tool with an output schema, the description is adequately complete. It states the core purpose, though it could have added a phrase like 'read-only' for extra safety clarity, but that is not essential here.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. The description correctly adds no parameter-specific details, as there are none to explain.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Lists') and resource ('installed plugins in the Airflow system'), making the purpose immediately clear. It distinguishes itself from sibling tools by being the only one focused on plugins.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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, or any exclusions or prerequisites. The description only states what it does, not in which context it is the preferred choice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 adds useful context by disclosing the v1/v2 difference and that v2 uses Assets. However, it does not describe the return format, potential errors, or authentication needs, though the output schema may cover return shape.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that front-loads the core purpose and adds a version qualifier. There is no filler or redundant information, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter read tool with an output schema, the description covers the essential purpose and an important version distinction. It could explicitly differentiate from list_datasets or note read-only behavior, but the low complexity and output schema make this sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not elaborate on dataset_uri (e.g., format, examples, required semantics). The parameter name is self-explanatory to a degree, but the description fails to compensate for the lack of schema documentation, adding no meaning beyond the schema field.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool gets details of a specific dataset, with a specific verb ('gets details') and resource ('dataset'). It also distinguishes from sibling tools by noting this is v1 API only and v2 uses Assets, which helps differentiate it from other dataset-related tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides context for when to use this tool by noting it is v1-specific and that v2 uses Assets. However, it does not explicitly name alternatives like list_datasets or provide exclusions beyond the version caveat, so it's clear but not exhaustive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states the core behavior—listing all provider packages—but does not mention return format, permissions, potential latency, or any other traits. For a simple read-only list operation, this is adequate but leaves some room for additional context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, directly stating the purpose with no filler or redundancy. It is appropriately concise and front-loaded, earning its place without waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no annotations) and the presence of an output schema, the description is complete. It clarifies the scope ('all provider packages') and leaves no ambiguity about what is being listed. Additional details like return format are covered by the output schema, so no further prose is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema is empty, so the description is the only source of meaning. It conveys what the tool does, which satisfies the baseline for 0-parameter tools. No parameter-level guidance is needed or possible.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Lists' and identifies the resource as 'all provider packages installed in the Airflow system', making the tool's purpose unambiguous. It clearly distinguishes from siblings like get_provider (which targets a single provider) and list_plugins (which lists plugins).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description only states what the tool does and does not explicitly discuss when to choose it over alternatives or when not to use it. Usage is implied from the action—if the user needs to see all installed providers—but no explicit guidance or exclusions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses that the tool filters to 'currently running' DAG runs and returns a list, but it does not mention potential pagination, permission requirements, or empty-list behavior. The description adds the running-status filter, which is useful, but lacks deeper behavioral detail expected for a tool with no annotation safety signals.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is front-loaded with the action ('Lists') and immediately specifies the resource and scope. Every word earns its place, with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
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 is present, the description adequately covers the core purpose and scope. It clearly identifies what is being listed (running DAG runs) and in what context (Airflow cluster), making it complete for this simple tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there is no schema to compensate. According to the baseline rule for 0 params, the description already provides sufficient meaning through its clear statement of what the tool lists, making extra parameter explanation unnecessary.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Lists all currently running DAG runs in the Airflow cluster.' It uses a specific verb ('Lists'), identifies the resource ('DAG runs'), and adds a scope filter ('currently running'), which distinguishes it from sibling tools like list_dags or failed_dags.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context that this tool is for retrieving currently running DAG runs, implying when it should be used versus historical or failed runs. However, it does not explicitly mention alternatives or when not to use it, so it stops short of full exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry behavioral transparency. It discloses the return structure (dict with dags list, pagination info, total counts) and explains fetch_all behavior. It doesn't discuss permission requirements or performance impacts, but for a read-only listing tool this is reasonably transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: a one-line summary followed by clear Args and Returns sections. Every sentence provides necessary information with no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 5 parameters, an output schema, and no nested objects, the description is complete. It covers purpose, parameters, pagination/filtering options, and return payload composition. No additional context seems needed for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning the input schema only shows types and defaults. The description compensates fully by explaining each parameter's meaning: limit (max DAGs), offset (skip), fetch_all (bypass pagination), id_contains (filter by ID), and name_contains (filter by display name). This is valuable semantic content beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Lists all DAGs registered in the Airflow cluster with pagination support.' This distinguishes it from siblings like get_dag (single DAG), get_dags_detailed_batch (batch detail), running_dags, and failed_dags by specifying the full list scope and pagination.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context: use this to list all DAGs with optional filters and pagination. It does not explicitly mention alternatives or exclusions, but the scope is defined well enough to infer when this tool is appropriate compared to more specific sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![mcp-airflow-api MCP server](https://glama.ai/mcp/servers/fastmcp-me/mcp-airflow-api/badges/card.svg)](https://glama.ai/mcp/servers/fastmcp-me/mcp-airflow-api)

Score Badge

Copy to your README.md:

[![mcp-airflow-api MCP server](https://glama.ai/mcp/servers/fastmcp-me/mcp-airflow-api/badges/score.svg)](https://glama.ai/mcp/servers/fastmcp-me/mcp-airflow-api)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/fastmcp-me/mcp-airflow-api'

If you have feedback or need assistance with the MCP directory API, please join our Discord server