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

With no annotations, the description must disclose behavioral traits but only states 'Create or update'. It does not explain whether updates overwrite existing definitions, what happens on duplicate names, or any permission requirements. The lack of detail leaves significant ambiguity for a mutation tool.

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

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

The description is a single sentence with no wasted words, but it is too brief to convey necessary detail. It achieves conciseness at the expense of completeness, which is not ideal.

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

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

Given the tool has an output schema (not shown), the description does not need to explain return values, but it lacks essential context about behavior (e.g., idempotency, if it's a full replacement). The parameter descriptions are absent, and the complexity of 'create or update' is not addressed, making the description incomplete.

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

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

Schema coverage is 0% and the description adds no meaning to the two parameters (name, definition). Both are just listed as string types without any explanation of their purpose, format, or constraints. This is a crucial gap for a tool with only two required parameters.

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

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

The description uses the verb 'Create or update' and specifies the resource ('Perses dashboard definition') and the context ('in GreptimeDB'), making the function clear. It distinguishes from sibling tools like delete_dashboard and list_dashboards, but the dual action (create/update) slightly reduces specificity.

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

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

No guidance is provided on when to use this tool versus alternatives, nor are there any exclusions or prerequisites mentioned. The agent must infer usage from the tool name and context.

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

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

With no annotations provided, the description carries the full burden. It states 'Create' implying mutation but lacks details on idempotency, side effects, permissions, error behavior (e.g., overwriting existing pipelines), or any constraints.

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

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

At one sentence, it is concise but sacrifices substance. It is front-loaded with the action and resource, but does not earn its brevity with added value beyond the obvious.

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

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

Given the minimal description, lack of parameter details, no annotations, and existence of an output schema (unused), the description is incomplete. It fails to cover essential context for a tool with two required parameters.

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

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

Schema description coverage is 0%, yet the description adds no information about the two required parameters 'name' and 'pipeline'. It does not explain what values are expected, defaults, or formats, leaving the agent uninformed.

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

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

The description uses a specific verb 'Create' and identifies the resource 'pipeline' in GreptimeDB, clearly distinguishing it from siblings like 'create_dashboard', 'delete_pipeline', and 'dryrun_pipeline'.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'dryrun_pipeline' for testing or 'list_pipelines' for inspection. There are no prerequisites, context, or use case hints.

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

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

No annotations provided; description only states 'delete' but lacks details on consequences, permissions, or reversibility.

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

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

Single sentence with 9 words, straight to the point, no filler.

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

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

Despite having an output schema, the description is too minimal for a destructive operation; lacks context on naming conventions or effects.

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

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

Schema coverage is 0% and the description does not explain the 'name' parameter beyond the schema title, failing to add meaning.

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

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

Description clearly states the verb 'delete' and resource 'Perses dashboard definition from GreptimeDB', distinguishing it from siblings like delete_pipeline.

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

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

No guidance on when to use this tool versus alternatives, no prerequisites or when-not-to-use mentioned.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as irreversibility, permission requirements, or side effects on other pipeline versions. The single word 'Delete' gives no further insight.

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

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

A single, front-loaded sentence that efficiently conveys the tool's purpose without any 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.

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

The description covers the basic purpose but omits details about error handling, idempotency, and behavior when the pipeline version does not exist. An output schema exists, so return values are not required, but overall completeness is adequate for a simple delete operation.

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

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

With 0% schema description coverage, the description adds the phrase 'specific version' which clarifies the version parameter's role. However, no additional constraints, formats, or examples are provided. The parameter names are self-explanatory, but the description adds minimal extra value.

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

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

The description clearly states the action (Delete), the resource (a specific version of a pipeline), and the context (from GreptimeDB). It distinguishes well from sibling tools like create_pipeline and list_pipelines.

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

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

No guidance is provided on when to use this tool versus alternatives, what prerequisites are needed, or when not to use it. Implied context from the name is minimal.

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

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

With no annotations, the description carries the full disclosure burden and largely succeeds: it explains that the semantic profile is about meaning, not data, defines signal_type/source/pipeline, and cautions that metadata_quality says nothing about telemetry quality and null means unknown. It does not explicitly state read-only behavior, but the 'profile' framing makes that reasonably clear.

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

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

The structure is effective: a front-loaded one-sentence summary, a short usage-routing paragraph, then a focused semantic-field explanation. It is longer than strictly necessary but every section carries useful content, with no filler.

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

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

Because an output schema is present, the description needn't spell out return values. The description covers semantic interpretation, null semantics, and sibling routing. The main remaining gaps are sample_limit behavior and an explicit statement of read-only/no-side-effect guarantees.

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

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

Schema description coverage is 0%, so the description must compensate. It does add meaning by detailing what the semantic profile contains and mentioning sample rows, which indirectly clarifies include_semantics and include_samples. However, it never directly explains sample_limit, include_samples/include_semantics flag effects, or the required table parameter, leaving a portion of the parameter semantics to inference.

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

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

The description opens with a specific verb and object ('Get a table profile') and lists its contents: schema, semantic metadata, sample rows, and guidance. It also positions the tool against the nearest sibling by explicitly saying search_table_semantics is the choice when the right table is unknown, so there is no ambiguity about this tool's distinct role.

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

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

It gives an explicit trigger ('Use it when deciding how to query an unfamiliar table') and an explicit exclusion ('When the right table is not known yet, search_table_semantics first'), with a rationale that describing candidates is slower than querying the data. This is strong, actionable routing guidance.

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

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

With no annotations, the description carries full burden. It explicitly states the tool does not write to the database, a key behavioral trait. It does not mention permissions, side effects, or error handling, but the 'dryrun' name reinforces the read-only nature. Sufficient for a non-destructive test tool.

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

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

The description is concise, with a short paragraph front-loading the core purpose, followed by a clear list of arguments. Every sentence adds value, and the structure is easy to read.

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

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

Given the tool has 4 parameters and an output schema, the description covers the two usage modes and all parameters adequately. It could mention that the output schema describes return values, but that is covered by the output schema itself. Missing some details on data format validation, but overall complete.

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

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

Schema description coverage is 0%, so the description must add meaning. It clearly explains each parameter: pipeline (inline YAML), pipeline_name (saved, mutually exclusive), data (test data), data_type (optional). It also notes the mutual exclusivity, providing essential semantics beyond the schema's titles.

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

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

The description clearly states the tool tests a pipeline with sample data without writing to the database, distinguishing it from siblings like create_pipeline or delete_pipeline. The verb 'Test' and resource 'pipeline' are specific, and the 'without writing' differentiates from mutation tools.

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

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

The description explains two mutually exclusive usage modes (inline YAML vs saved pipeline) and lists required arguments. It implicitly tells when to use by contrasting with writing to database, but lacks explicit 'when not to use' or alternatives.

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

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

No annotations provided. Description discloses read-only default and write mode conditions, but lacks details on error handling, transaction behavior, or performance implications.

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

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

Three short sentences, front-loaded with purpose, no fluff. Every sentence adds value.

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

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

Covers main usage and permissions. Output schema exists, so return values are covered. But parameter semantics are missing; given 3 params and no description of them, completeness is moderate.

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

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

Schema description coverage is 0%, but description does not explain any parameter meanings (e.g., query, format, limit). Only tool context is provided, leaving schema to carry full burden.

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

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

Description clearly states verb 'Execute' and resource 'SQL query against GreptimeDB', with specific mention of MySQL dialect. Distinguishes from sibling execute_tql.

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

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

Explicitly states read-only default and conditions for enabling write mode. Does not directly compare with alternatives, but sibling names suggest distinct purposes.

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

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

No annotations provided, so the description must carry the full burden. It does not disclose whether the operation is read-only, destructive, or requires special permissions. No mention of side effects, rate limits, or response characteristics.

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

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

The description is extremely short (two sentences) but front-loads the core purpose. However, it sacrifices critical details for brevity, resulting in below-average informativeness.

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

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

Despite having an output schema, the description omits key context: how to handle large result sets, error conditions, or time-series semantics. For a complex query tool, the description is insufficient.

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

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

Schema description coverage is 0%, yet the description only explains the query syntax ('PromQL-compatible') without detailing parameters like start, end, step, lookback, or format. The agent cannot infer constraints or defaults from the description alone.

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

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

The description clearly states the action ('Execute TQL query') and the domain ('time-series analysis'). It also mentions PromQL compatibility, distinguishing it from SQL queries (execute_sql) and other time-series tools (query_range).

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

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

No explicit guidance on when to use this tool versus alternatives like execute_sql or query_range. The mention of PromQL compatibility hints at syntax but does not provide decision criteria such as performance, authentication, or scope.

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

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

With no annotations, the description must disclose behavioral traits. It states 'analyze' which implies a read-only, non-destructive action, but does not confirm this or mention any side effects, permissions, or rate limits. The agent cannot determine if the operation is safe without 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.

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

The description is a single sentence, which is concise but lacks essential details about parameters and usage. It front-loads the basic purpose, but does not earn its place by covering critical information. An adequate length given the tool's simplicity, but insufficient depth.

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

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

Given the parameter count of 3, 0% schema coverage, and no annotations, the description is incomplete. It does not explain return values (though an output schema exists) or parameter purposes. The agent lacks 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.

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

Schema description coverage is 0%, yet the description does not mention any of the three parameters (query, analyze, verbose). It adds no meaning beyond the raw schema, resulting in no semantic value for the agent.

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

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

The description states 'Analyze SQL or TQL query execution plan,' which clearly identifies the tool's action (analyze) and target (execution plan). It distinguishes from sibling tools like execute_sql and execute_tql by focusing on plan analysis rather than execution. However, it does not explicitly contrast with these siblings, preventing a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It lacks any 'when to use' or 'when not to use' context, leaving the agent to infer based on the tool name alone.

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

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

The description indicates a read-only check operation. No annotations are provided, but the tool's benign nature is clear. It does not contradict annotations (none exist), and the behavior is transparent.

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

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

The description is a single sentence that is concise and front-loaded, with no extraneous information.

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

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

The tool has an output schema, so return values are documented elsewhere. The description covers the purpose fully for a simple health check, and the zero parameters make it complete.

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

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

The tool has no parameters, so the schema coverage is 100%. The description adds no parameter information, but none is needed. Baseline 4 for zero parameters.

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

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

The description clearly states the tool checks GreptimeDB connection status and server version. It uses a specific verb ('Check') and resource, distinguishing it from sibling tools like create_dashboard or execute_sql.

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

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

The description implies the tool is for checking connectivity and version, but lacks explicit guidance on when to use it versus alternatives (e.g., execute_sql for a test query). 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.

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

No annotations are provided, so the description must disclose behavioral traits. It correctly indicates a read-only operation ('List') with no destructive side effects. However, it does not mention pagination, rate limits, or authentication requirements.

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

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

The description is a single sentence that is front-loaded with the verb and resource. No wasted words; every part earns its place.

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

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

For a simple list tool with no parameters and an output schema provided, the description is complete enough. It tells the agent exactly what the tool does without missing critical information.

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

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

There are no parameters, so schema coverage is 100%. The description does not need to add parameter meaning, but it correctly implies no filtering is possible. Baseline for zero parameters is 4.

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

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

The description clearly states the verb 'List' and the specific resource 'all Perses dashboard definitions stored in GreptimeDB.' It distinguishes this tool from siblings like create_dashboard, delete_dashboard, and list_pipelines.

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

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

The description implies a simple use case of listing all dashboards, but it does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives like execute_sql for filtered queries.

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

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

No annotations are present, so the description bears full responsibility. It only states the basic operation (list/details) but fails to disclose any behavioral traits such as rate limits, pagination, read-only nature, or what happens if the pipeline doesn't exist. The output schema exists but is not described.

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

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

The description is concise with a single sentence that conveys the core functionality. It is front-loaded with the verb and resource, but could be more structured by separating the two modes explicitly.

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

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

Given the simple parameter and presence of an output schema, the description is minimally adequate. It covers the two use cases but lacks details about return structure, error handling, or behavioral constraints that would make it fully complete for an AI agent.

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

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

With 0% schema description coverage, the description adds minimal value: it implies that providing a 'name' gives details, while omitting it lists all. However, it does not explain the format, constraints, or behavior of the parameter beyond what the schema already indicates.

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

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

The description clearly states the verb 'list' and resource 'pipelines', and indicates two modes: list all or get details of a specific pipeline. This is clearly distinct from sibling tools which operate on different resources like dashboards or SQL.

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

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

The description does not provide any guidance on when to use this tool versus alternatives, nor does it mention prerequisites or when not to use it. This lack of context forces the AI to infer usage from the tool name alone.

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

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

With no annotations, the description should disclose behavioral traits like idempotency or side effects. It only describes the action without mentioning any constraints or implications.

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

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

The description is a single, concise sentence with no unnecessary words or information.

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

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

Given the tool has 9 parameters, no schema descriptions, and no annotations, the single-sentence description is severely lacking. The output schema exists but is not utilized in the description.

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

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

Schema coverage is 0% and the description adds no details about any of the 9 parameters, leaving the agent entirely dependent on parameter names.

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

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

The description clearly states the tool executes time-window aggregation queries using GreptimeDB's RANGE syntax, which is specific. However, it does not differentiate from sibling tools like execute_sql or execute_tql that might also handle queries.

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

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

No guidance is provided on when to use this tool versus alternatives, nor are there any conditions or prerequisites mentioned.

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

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

With no annotations, the description carries the full burden, and it delivers: it reveals the confidence 1.0/0.5 representation, duplicate rows for edges observed both ways, half-open windows over observed_at buckets, row-level semantics for entities (item_count counts rows, not entities), behavior when complete is false, masking effects, and the caveat that a missing edge is not evidence of non-relation. This is far beyond the structured fields.

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

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

The text is long but every paragraph earns its place and is organized by topic: purpose, window, per-view row semantics, ordering, interpretation caveats, provenance, and masking. The main purpose and view-selection rule are front-loaded in the first two sentences, so an agent quickly gets the gist without needing the later detail.

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

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

Given 13 parameters, no annotations, and a complex output schema, the description is unusually complete: it covers view-specific behavior, edge cases (sampling, unmatched clients, identity deduplication), ordering rules, provenance, and masking. Nothing an agent needs to call this tool correctly appears to be missing.

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

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

Schema coverage is 100%, but the description adds meaning the schema does not: it defines the window as half-open over observed_at 60-second buckets, clarifies that rel_type=calls is needed to order by error/request counts, explains what limit echoes and what complete=false means, and details provenance/identity semantics for src_id/dst_id and entity_id. That is substantial added value over the baseline.

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

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

The opening sentence names a specific verb ('Query'), a specific resource ('semantic graph'), and the two core questions it answers ('which entities exist and which are related'). It further distinguishes the three views (summary, entities, relationships) at a high level, so an agent can tell it apart from sibling data-query tools without reading the schema.

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

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

The description gives clear internal routing: use view=summary when types are unknown, and query entities or relationships directly once a type or id is in hand. It does not explicitly contrast this tool with sibling tools like execute_sql or query_range, so the when-not-to-use guidance for the tool itself is left implicit, but the context is strong.

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

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

With no annotations, the description carries full disclosure burden and does so exceptionally. It states the search is metadata-only, never reads telemetry row values; it clarifies ranking is based on metadata values, not key names; and it discloses coverage limits and the possibility of false negatives. This is rich behavioral context well beyond the schema.

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

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

Although long, every sentence adds unique operational value: purpose, matching behavior, usage timing, ranking caveat, follow-up guidance, scope boundary, and visibility limitation. The most important instruction is front-loaded, and there is no filler or tautology.

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

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

Given the tool's complexity and no annotations, the description covers purpose, scope, limitations, alternative tools, follow-up actions, and fallback behavior. Since an output schema exists, the description need not explain return values, and nothing essential for correct invocation is missing.

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

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

The schema has 0% description coverage, so the description must compensate. It gives strong guidance for the `query` parameter ('search for `gauge` or `bytes` rather than `metric type`'), but it never explains `signal_type` or `limit`. This leaves meaning for two of three parameters under-specified, so the compensation is only partial.

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

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

The description opens with a specific verb and resource: 'Find tables by observability concept when the right table name is unknown.' It clearly distinguishes itself from describe_table by explaining it searches schema metadata and ranks matches, so an agent can tell what the tool does without reading the schema.

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

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

Usage is explicitly prescribed: 'Use it before describe_table when the schema is wide or table names do not say what they hold.' It also gives direct follow-up guidance ('query their data or describe one of them; do not describe every candidate in turn') and an explicit fallback ('fall back to SHOW TABLES'), making when-to-use and when-not-to-use unambiguous.

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