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

No annotations are provided, so the description must carry full behavioral transparency. It discloses that the dataframe is available as 'df' and that you need to assign to 'result' to return values, which is helpful. However, it doesn't mention any potential side effects, execution sandboxing, or error handling behavior. It does state the return is a string representation, partially covering behavioral aspects.

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

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

The description is well-structured: it starts with a one-line summary, then details the parameters, return type, and includes a relevant example. The example is not overly long but demonstrates complex usage. Some redundancy exists ('Execute multi-line pandas code' is repeated), but overall it's efficient and front-loaded with the core purpose.

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

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

The tool is moderately complex with 3 parameters and an output schema, but the description doesn't explain the output schema's contents. It does provide an example that clarifies usage. Missing details: what happens if code fails, how to handle large data, or what 'df' contains exactly. The example covers a common use case, but edge cases are not addressed.

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

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

Schema coverage is 0%, so the description must compensate. It explains 'query_tuple' as a tuple of (zone/component, report_name, table_name), and 'code' is shown with examples that demonstrate usage. The 'id' parameter is only mentioned as 'model_id' but with a reference to get it from get_available_models. While not exhaustive, it provides meaningful meaning beyond the bare schema.

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

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

The description clearly states it executes multi-line pandas code on HTML table data and provides context about EnergyPlus. It differentiates from siblings by focusing on multi-line code versus single-line (execute_pandas_on_html_table) and HTML table versus timeseries (execute_multiline_pandas_on_timeseries).

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 a specific scenario (complex table analysis) but doesn't explicitly state when not to use it or alternatives. It does mention obtaining model_id from get_available_models, which gives some usage context, but lacks exclusions like 'use execute_pandas_on_html_table for single-line code'.

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

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

No annotations are provided, so the description carries the full burden. It discloses the return behavior ('String representation of the result or execution status') and explains the execution mechanism (code runs against a dataframe bound to 'df'). However, this is an arbitrary code execution tool and the description offers no safety caveat, no error-handling notes, and no warning about what the execution environment permits. The core behavior is disclosed, but meaningful behavioral context for a code-execution tool is missing.

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

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

The description is front-loaded with its purpose and stays efficient. The included code example is substantial but earns its space by demonstrating real multi-step usage of df, groupby, and result assignment. Every sentence serves a purpose, though the example adds length that could be trimmed for brevity without losing 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?

For a code-execution tool with zero annotations and an output schema (string return), the description covers purpose, all three parameters, return format, and a concrete example. Gaps remain in error/timeout behavior and safety considerations for arbitrary code, but the essential calling contract is fully specified. The complexity of this tool is high, and the description handles most of it well.

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 fully compensate, and it does. Each parameter is given meaning beyond its schema entry: model_id is tied to get_available_models, rddid is clarified as a list of RDD IDs obtained from get_sql_available_hourlies, and code is explained with the df/result conventions plus a worked example. All three parameters are effectively documented despite the empty schema.

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

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

The description uses a specific verb ('Execute') with a clear resource ('multi-line pandas code on timeseries data from an EnergyPlus model'). It distinguishes itself from sibling tools like execute_pandas_on_timeseries (single-line) and execute_multiline_pandas_on_html_table (multi-line on HTML tables) by specifying both the multiline and timeseries dimensions. An agent can identify this tool's purpose without opening 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 explains how to use the tool mechanically (df variable, 'result = ...' to return values) and points to sibling tools for obtaining parameters (model_id from get_available_models, rddid from get_sql_available_hourlies). However, it never explicitly contrasts this tool with its close siblings — it does not say when to prefer multiline over single-line pandas execution or timeseries over HTML table variants. The usage context is present but exclusions/alternatives are left to inference.

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 behavioral disclosure burden. It does reveal that the tool executes arbitrary multi-line Python, returns a formatted result or status message, and rejects import and print statements. However, it does not disclose whether the executing code can mutate the cached DataFrame, what variables are in scope, or how errors are surfaced, leaving meaningful behavioral gaps.

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

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

The description is concise and well-organized with Args, Returns, and Notes sections. It front-loads the core purpose and avoids fluffeur or repeated enumeration. A short example or a mention of the available DataFrame variable would add value without harming conciseness.

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

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

For a code-execution tool with no annotations and no schema-level parameter descriptions, the description is incomplete. It omits how to reference the DataFrame in the query, whether the query can modify cached state, and what a valid multi-line operation looks like. The return type is stated, but the execution contract is underspecified.

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 explain file_hash as the hash of the loaded parquet file and query as multi-line Python code, which is more than the schema provides. But it stops short of describing the execution environment, such as the variable name that refers to the DataFrame, which is essential for writing a correct query.

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 ('Execute'), the resource ('cached DataFrame'), and a clear qualifier ('multi-line pandas operations'). This distinguishes it from sibling tools that target timeseries or HTML tables, and from the likely single-line execute_query. The purpose is explicit and unambiguous.

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

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

The description implies when to use the tool: for multi-line pandas operations against a cached parquet-backed DataFrame. However, it does not explicitly contrast it with execute_query or the other pandas execution siblings, and it does not give conditions for selecting one tool over another. The note about import/print statements is a content restriction, not an alternative-routing guideline.

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

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

No annotations are provided, so the description carries the burden. It discloses the core behavior: it retrieves the table, makes it available as 'df', executes the pandas query, and returns a string representation. It does not disclose error behavior, query limitations, or performance considerations, which would be valuable for an arbitrary code-execution 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 structure is effective: a summary line, mechanics explanation, Args section, Returns note, and examples. The first two sentences are somewhat redundant, but the rest earns its place. The examples are especially useful and not padded.

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 3-parameter tool, the description covers the model id source, table identification, query format, and return shape. It does not address edge cases or distinguish the single-line pandas variant from the multiline sibling, but the essential invocation context is 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 is the only parameter documentation. It explains id, query_tuple's structure (zone/component, report_name, table_name), and query as a pandas expression. The three examples further clarify expected usage. This fully compensates for the uninformative schema.

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

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

The description opens with a specific action and resource: 'Execute pandas operations on HTML table data from an EnergyPlus model.' It clarifies that it retrieves an HTML table and exposes it as 'df', which is clear and non-tautological. However, it does not explicitly contrast with sibling pandas tools like execute_pandas_on_timeseries or the multiline HTML-table variant, so sibling differentiation is partial.

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 intended context is clear: use this tool when you have an HTML table from an EnergyPlus model and want to run pandas operations on the exposed dataframe. It also points the agent to get_available_models for obtaining the model id. It provides no explicit when-not-to-use guidance or alternatives, but the context is strong enough to guide selection.

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

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

With no annotations provided, the description carries the behavioral transparency burden. It discloses that the tool retrieves timeseries data, executes a pandas query, provides 'df' inside the query, and returns a string representation. It does not mention side effects, safety implications of arbitrary pandas execution, or error behavior, but it does describe the core runtime behavior.

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

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

The description is well organized into summary, args, returns, and examples. It is slightly redundant in the first two sentences, but the structure is front-loaded and the examples are useful rather than 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?

For a tool of moderate complexity with 0% schema coverage, the description covers prerequisites, dataframe naming, query expectations, return format, and usage examples. It is complete enough for an agent to call the tool correctly, though it could strengthen sibling differentiation and mention any limitations on acceptable pandas expressions.

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 fully compensates by explaining every parameter: model_id's source, rddid's meaning and source, and query's syntax with multiple concrete examples. The examples show exactly how the query string is expected to reference 'df', 'Value', and 'dt', adding substantial semantic value beyond the raw schema.

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

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

The description clearly states a specific verb and resource: executing pandas operations on EnergyPlus timeseries data. It makes the data available as 'df', which gives concrete operational meaning. It doesn't explicitly distinguish itself from sibling tools like execute_multiline_pandas_on_timeseries, so it misses the full sibling-differentiation bar.

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

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

The description implies when to use the tool by showing pandas-style query examples and explains prerequisites (obtain model_id from get_available_models, rddid from get_sql_available_hourlies). However, it does not explicitly state when to prefer this over alternatives such as execute_multiline_pandas_on_timeseries or get_timeseries_report_by_rddid_list, so usage guidance is present but not decisive.

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 carries the full burden of behavioral disclosure. It states that a pandas query is executed and that a formatted string is returned, but it does not disclose prerequisites (e.g., that the file must already be loaded/cached), safety implications of executing arbitrary pandas expressions, or failure behavior.

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

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

The description is concise and front-loaded with the core purpose, followed by Args and Returns sections. Every sentence earns its place, though it is sparse enough that some substance is missing.

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

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

For a two-parameter tool with an output schema, the description provides the minimal essentials needed to attempt a call. However, given the large set of sibling tools and the absence of usage guidance or safety context, it is not fully complete for an agent deciding among execute_query, execute_multiline_query, and the pandas-on-timeseries variants.

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 explaining file_hash as the hash of the loaded parquet file and query as the pandas query to execute, but it provides no examples, constraints, or format details beyond the bare schema names and types.

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 a pandas query') and the resource ('cached DataFrame'), with file_hash identifying the specific loaded parquet file. It mostly distinguishes itself from siblings like execute_pandas_on_timeseries and execute_pandas_on_html_table by targeting the cached DataFrame, but it does not explicitly distinguish itself from execute_multiline_query.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention that this is for single-line pandas queries, nor does it point to siblings such as execute_multiline_query or execute_pandas_on_timeseries for other cases.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It transparently notes that the directory parameter is currently ignored and that the tool uses a default directory, and it explains the shape of the returned data. This is solid for a read-only discovery tool, though it stops short of stating side-effect-free behavior explicitly.

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

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

The description is well-structured with a front-loaded summary followed by concise Args and Returns sections. Each part earns its place, and the return-field enumeration is useful rather than redundant given the lack of an output schema.

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 listing tool with one optional parameter and no output schema, the description covers the essential information: what is retrieved, how the parameter behaves, and the exact fields in the returned dictionaries. It lacks explicit sibling comparisons or edge-case behavior, but nothing critical is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must explain the only parameter. It does so by stating that directory is ignored and the default directory is used, which is essential behavior not inferable from the schema alone. This fully compensates for the missing schema-level description.

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: 'Retrieve all available EnergyPlus models and their metadata.' It clearly states what the tool returns and that the unique identifiers are meant for use with other tools, which distinguishes it from the sibling tools that operate on specific models or files.

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 makes the tool's role in the workflow clear: it is the discovery entry point that returns model IDs for later use with other tools. There are no explicit exclusions or alternative routing instructions, but the context is clear enough for an agent to know when listing available models is needed.

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 behavioral burden. It does disclose the read-only nature ('Retrieve') and the return format ('Plain text output of EPlus error file'), which is helpful. It does not mention behavior for missing IDs, empty files, or any required initialization steps (e.g., initialize_model_map), leaving some gaps.

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

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

The description is compact, front-loaded, and organized with clear Args and Returns sections. 'Useful in debugging' adds minor context without bloating the text, and no schema details are redundantly repeated.

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

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

For a simple one-parameter retrieval tool, the description covers the essential information: the parameter's meaning/source and the output type. It lacks edge-case details like error handling or empty-file behavior, but those are not critical for making a correct invocation.

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

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

The schema only says id is a string, but the description clarifies that id is 'the model_id of the EnergyPlus model' and directs the agent to get it from get_available_models. This provides crucial semantic context and fully compensates for the 0% schema description coverage.

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

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

The description opens with a specific verb 'Retrieve' and a specific resource: 'a specific Error file from an EnergyPlus model using ID.' This makes the tool's purpose clear without needing the schema. It does not explicitly differentiate itself from sibling retrieval tools like get_rdd_file, so it does not earn a 5.

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

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

The description provides a usage context ('Useful in debugging') and an explicit prerequisite for obtaining the id from get_available_models. However, it does not state when to prefer this tool over alternatives or mention any exclusion criteria or when NOT to use it.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses the return format as a JSON string with columns and rows, but it does not mention error behavior, empty results, permission requirements, or potential side effects. For a read-style retrieval tool, the disclosed return format is helpful but not exhaustive.

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 compact and organized into an overview plus Args/Returns sections. The opening sentence is direct, and the parameter explanations are useful. Minor redundancy exists in the query_tuple field explanation, but overall it is efficient.

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

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

For a two-parameter tool with an output schema, the description covers the core invocation needs. However, it lacks examples or allowed values for report_name and table_name, and it does not explain what happens when the tuple does not match a table. This leaves some ambiguity for an agent deciding or recovering from failures.

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 the description compensates by defining id as the model_id from get_available_models and explaining that query_tuple contains (zone/component, report_name, table_name). This adds essential meaning that the minimal schema lacks.

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 identifies a precise verb-resource pair: retrieve a specific HTML table from an EnergyPlus model. It also clarifies the retrieval mechanism (tuple query), which differentiates it from related tools like search_html_tables_by_keyword.

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 that id comes from get_available_models and that query_tuple selects the table, giving useful context. However, it does not explicitly state when to use this tool over sibling alternatives such as search_html_tables_by_keyword or execute_pandas_on_html_table.

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 carries the full behavioral burden. It adds useful return details, including properties and property_count. However, it does not describe what happens for missing objects, case sensitivity, or any operational limits, which are relevant for an unannotated read 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 structured with an opening summary, Args list, and Returns list, making it scannable. It contains redundancy such as 'detailed properties,' 'all properties and values,' and 'complete configuration details,' but it is not excessively long.

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 three-parameter read operation with no output schema, the description covers the essential request and response shape. It is minimally viable but leaves gaps around when to use the tool, what counts as a valid object_type, and behavior when the object is not found.

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 needed to define all three parameters. It lists them, but the definitions are largely tautological: 'model_id: The model_id of the EnergyPlus model' and 'object_type: EnergyPlus object type.' No examples, formats, or allowed values are provided, so the description adds little meaning beyond the 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?

States a specific verb and resource: 'Get detailed properties of a specific EnergyPlus object' and 'Retrieves all properties and values for a specific object in the epJSON model.' The wording makes clear this is a direct lookup by known object identity, which reasonably separates it from sibling search/list tools even though no sibling is named.

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

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

The description gives no guidance on when to use this tool versus alternatives like search_epjson_objects or list_objects_by_type. It does not state prerequisites such as already knowing the exact object_type and object_name, nor does it mention when this lookup would be inappropriate.

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

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

With no annotations provided, the description carries the full burden. It discloses the return format ('Plain text output of RDD file') and its content, but it does not explicitly state that this is a read-only operation, nor does it mention error or failure behavior. Still, 'Retrieve' and the return description imply a safe lookup.

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 short, front-loaded with the main purpose, and cleanly structured with Args and Returns sections. No sentence is wasted or redundant.

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 single-parameter retrieval tool, the description covers purpose, input semantics, and return content. It lacks explicit read-only or error-behavior notes, which would be more important without annotations, but the provided output schema and straightforward nature reduce the gap.

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

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

Schema coverage is 0%, so the description fully compensates by explaining that 'id' is the model_id of the EnergyPlus model and telling the agent to obtain it from get_available_models. This is sufficient and valuable for the single parameter.

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

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

The description states a specific action ('Retrieve a specific RDD file...'), the resource type ('RDD file from an EnergyPlus model'), and the required identifier. This clearly differentiates it from sibling tools like get_error_file or list_objects_by_type.

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

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

The description gives clear context: it is useful in debugging, and it tells the agent where to get the required id (get_available_models). It does not explicitly list when not to use it or name alternatives, but the usage context is clear enough for a simple retrieval tool.

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

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

No annotations are provided, so the description carries the full burden. It clearly states the tool lists/discovers data and details the return contents, which implies a read-only operation. However, it does not explicitly state that there are no side effects, nor does it address potential edge cases like empty results or errors. The behavior is adequately conveyed but not deeply disclosed.

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

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

The description is well-structured with an intro, Args, and Returns sections, making it easy to scan. The opening two sentences are slightly redundant ('List available...' and 'Discovers all...') but both add useful nuance. Overall, 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.

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

With one simple parameter, a detailed Returns section in the description, and an output schema present, the tool is well covered. The only minor gap is that it references a tool named 'get_timeseries_report_by_rddid' while the sibling list shows 'get_timeseries_report_by_rddid_list'—a small naming mismatch that could cause slight confusion but does not undermine the overall completeness.

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

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

Schema coverage is 0%, so the description must compensate for the single parameter. It does so excellently: 'id: The model_id of the EnergyPlus model (obtain from get_available_models)' explains what the parameter is and exactly where to get it. This fully bridges the gap left by the minimal JSON schema.

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

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

The description uses a specific verb ('List', 'Discovers') and identifies the exact resource ('hourly timeseries variables in the SQL output for a specific model'). It also clarifies what is returned (variable names, RDD IDs, units) and how it differs from data-extraction tools by referencing downstream use with get_timeseries_report_by_rddid. This makes the tool's role unmistakable among the many siblings.

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 context: this tool is the discovery step before extracting timeseries data, and the id should come from get_available_models. It implies when to use it (need available variables/RDD IDs) but does not explicitly list alternatives or exclusion cases. Since it provides a clear usage context without exclusions, it earns a 4.

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

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

No annotations are provided, so the description carries the full behavioral burden. It clearly implies a read-only extraction and details the exact return record shape (dt, Value, Name, KeyValue, Units), which is strong disclosure. It does not mention potential large-result caveats, but the content is adequate for a retrieval tool.

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

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

The description is well-structured with Args, Returns, and an Example, making it scannable. There is slight redundancy between the first two sentences ('Retrieve...' and 'Extracts complete...'), but overall every major section 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?

Given there is no output schema, the description compensates by defining return fields and providing a workflow example. It does not mention pagination, maximum list sizes, or error behavior, but for a straightforward timeseries retrieval the key operational context is present.

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 explain the parameters. It does: model_id is sourced from get_available_models, and rddid is a list of integer RDD IDs sourced from get_sql_available_hourlies. This compensates for the empty schema descriptions, though it could add more detail on value formats or constraints.

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: 'Retrieve hourly timeseries data for a specific variable from an EnergyPlus model.' It further clarifies the mechanism (RDD ID) and names the prerequisite sibling tools, making its purpose distinct from get_sql_available_hourlies and the query 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 gives explicit workflow guidance: obtain model_id from get_available_models and rddid from get_sql_available_hourlies, with a concrete example. It does not explicitly state when not to use this tool versus other timeseries/query siblings, but the prerequisite chain makes the intended usage clear.

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

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

No annotations are provided, so the description carries the behavioral burden. It clearly communicates that the tool returns documentation, and the 'Get' verb combined with zero parameters makes the read-only, side-effect-free nature evident. It does not explicitly say 'read-only,' but there is no plausible mutation implied.

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 short and front-loaded with the primary purpose. However, the 'Returns:' line mostly duplicates the second sentence ('Returns detailed documentation...' vs. 'Returns: Complete usage instructions...'), so it is not maximally tight.

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

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

For a zero-parameter, no-annotation tool with an output schema, the description covers the essential purpose and content reasonably well. It could be strengthened by explicitly framing the tool as the onboarding/entry point for understanding the MCP server, but that is not a major omission.

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

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

The tool has zero parameters, so there is no parameter semantics to explain. The baseline for no-parameter tools is 4, and the description appropriately avoids inventing parameter details that do not exist.

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

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

The description uses a specific verb and resource: 'Get comprehensive usage instructions for the EnergyPlus MCP server.' It clearly states the tool's purpose and distinguishes it from the many simulation/data sibling tools by framing it as documentation/meta-guidance rather than a domain operation.

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 obtaining documentation and workflow guidance, but it never explicitly states when to prefer this tool over siblings or mentions alternatives. There is no 'use this when...' or 'use X instead for...' guidance, leaving the invocation context somewhat inferred.

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 burden of disclosing behavior; it does state that the tool scans a directory, builds/refreshes a cached model map, and returns a status message. However, it does not mention failure modes, what happens to existing cached data on refresh, or how the cache is stored, which are relevant details for a cache-writing operation.

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

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

The description is organized with an overview, a usage note, Args, and Returns, and the core purpose is front-loaded. The incorrect default and typo prevent a perfect score, but the structure is otherwise compact and efficient.

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

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

For a one-parameter initializer, the description covers the main flow, call order, and return type, and an output schema exists. It is incomplete about edge cases such as nonexistent directories, empty scans, or cache refresh side effects, and the wrong default value weakens overall reliability.

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 description identifies the directory parameter's role and mentions the file extensions scanned, which adds meaning beyond the schema. However, it claims the default is 'DEFUALT_DIRECTORY' while the schema default is 'eplus_files/prescriptive_variability_sample'; this misspelled and incorrect default is misleading for an agent deciding whether to pass the parameter.

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

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

The description states a specific verb ('Initialize or refresh') and resource ('the model map cache for EnergyPlus models'), and explains the mechanism by listing the scanned file types. 'Call this first before accessing model data' clearly separates this initialization tool from the many getter/query sibling tools.

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

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

It explicitly instructs agents to call this tool first before accessing model data, which is a clear when-to-use directive. It does not name sibling tools or state when not to use it, but the setup-versus-access distinction is sufficient for a simple initializer.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that it 'Retrieves all objects' and returns a dictionary with specific fields, implying a read-only operation and describing the response shape. However, it does not explicitly say that the operation is non-mutating, nor does it mention any side effects, permissions, rate limits, or pagination. The description adds some value by documenting the return structure, but it leaves important behavioral aspects (e.g., whether it modifies anything) unstated.

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

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

The description is well-structured: a one-sentence summary, a short explanatory paragraph, and clearly separated Args/Returns sections. It is front-loaded with the core purpose and avoids unnecessary detail. It is concise, at about 120 words, and every section adds value. The only minor repetition is the phrase 'object type', but overall the structure is clean and scannable.

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

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

Given that this is a simple list tool with 2 parameters and no annotations or output schema, the description covers the essentials: what it does, the parameters, and the return structure. It documents the four keys of the returned dictionary, which is helpful. However, it does not address error cases, what happens if the object_type is invalid, whether there are any limits on the number of objects returned, or if there is any pagination. For a tool relying on its description alone (no annotations), this is a noticeable gap, though not severe for a straightforward list operation.

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

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

Schema description coverage is 0%, so the description must compensate. It provides a line for each parameter: 'model_id: The model_id of the EnergyPlus model' and 'object_type: EnergyPlus object type to list'. This is barely more than restating the parameter names; it does not explain what a valid object_type looks like, provide examples, or clarify the format of model_id. It meets the minimum bar by confirming what each parameter refers to, but it does not enrich the schema meaningfully.

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 resource 'objects of a specific type in the epJSON model', and it elaborates with 'Retrieves all objects of a specified EnergyPlus object type, providing an overview'. This is unambiguous and distinguishes it from sibling tools like get_object_properties (which fetches a specific object) or search_epjson_objects (which filters). However, it does not explicitly name these siblings, so it doesn't fully differentiate itself, which is why it doesn't get a 5.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It implies it is for getting an overview of all objects of a type, but it never says 'use this when you want to see all components' or contrasts it with search or property retrieval. There are no exclusions or conditions. The agent must infer the intended use from the tool name and the high-level purpose, which is vague.

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

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

There are no annotations, so the description carries the full burden. It clearly describes the search behavior and the returned dictionary with 'search_results', 'search_criteria', and 'search_stats'. It does not specify edge cases or matching semantics exactly, but the core behavior and output structure are disclosed.

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

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

The layout is clean and well-organized with Args and Returns sections. However, the opening two sentences are somewhat redundant: 'Search for specific objects...' and 'Searches through the epJSON model data...' convey nearly the same information, so the description is slightly less concise than it could be.

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

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

The tool has 5 parameters and no output schema, but the description covers all parameters and explains the return format. It is mostly complete for invoking the tool correctly, though it leaves ambiguous how 'object_name' and 'search_pattern' interact or whether they are mutually exclusive.

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

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

Schema description coverage is 0%, and the description fully compensates by documenting all five parameters with clarifying examples. Each parameter gets additional meaning beyond the bare schema title, especially 'object_type' and 'search_pattern' with realistic EnergyPlus examples.

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 and target: 'Search for specific objects in epJSON data structure' and 'find objects matching the specified criteria.' It is specific enough for an agent to know the tool's job, but it does not explicitly differentiate itself from the sibling tool 'search_related_objects' or other search/list 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 line 'Useful for finding specific components, systems, or zones within the building model' gives some context for when to use the tool)Skip but offers no exclusions or alternatives. With multiple sibling search tools, an agent receives little explicit guidance about when to prefer this tool over 'search_related_objects' or 'list_objects_by_type'.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It covers how matching works (keyword matches in table names, report names, or other metadata), the case_sensitive default behavior, and the full return structure. It could additionally state that this is a read-only/search operation, but the described behavior is otherwise transparent.

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

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

The description is well-structured with clear sections: summary, args, returns, examples, and keyword categories. The common keyword categories are lengthy but genuinely useful for an agent choosing search terms. It is longer than minimal, but the content is organized and mostly 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?

With no output schema present, the description compensates by listing the exact return dictionary fields. It also documents all parameters, gives multiple usage examples, and provides domain-specific keyword guidance. An agent has everything needed to call the tool correctly and interpret its result.

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

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

Schema description coverage is 0%, so the description must fully explain the parameters. It does: id is tied to get_available_models, keywords are defined with concrete examples, and case_sensitive is explained with its default. This adds substantial meaning beyond the bare input schema.

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

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

The description states a specific verb and resource: 'Search for HTML tables containing specific keywords in their names.' It also clarifies the matching scope (table names, report names, or metadata) and includes examples, making the tool's purpose unmistakable and distinct from siblings like get_html_table_by_tuple.

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 usage context: it is 'useful for finding specific types of tables like cooling, heating, energy, etc.' and provides examples. It does not explicitly contrast this tool with alternatives such as get_html_table_by_tuple or execute_pandas_on_html_table, so it stops short of full when-to-use-versus-other-tools 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 present, the description carries the burden of behavioral disclosure. It does explain that matching is based on object names containing a pattern and describes the return dictionary structure. However, it does not disclose whether matching is case-sensitive, substring-based vs regex, whether it searches only names or also values, or whether there are any limits on scope or result size.

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

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

The description is well-structured: purpose first, then an explanatory sentence, followed by Args and Returns sections. The opening two sentences are slightly redundant ('Search for...' and 'Finds all objects...'), but overall every section earns its place without bloated 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?

Given the tool is relatively simple and has only two parameters, the description provides the essentials: what it searches, what inputs it takes, and what the return dictionary contains. It falls short on pattern-matching semantics, case sensitivity, and routing the agent away from overlapping sibling tools, so it is adequate but not 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 input schema has no parameter descriptions, so the description must compensate. It defines model_id as 'the model_id of the EnergyPlus model' and search_pattern as 'Pattern to search for' with a concrete example ('ROOM_1_FLR_3'). This provides enough meaning for both parameters, though model_id's description is still thin and no format or required-prefix details are given.

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

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

The description clearly states that the tool searches the epJSON model for objects whose names contain a given pattern, with an explicit resource (epJSON model) and action (search/find). It is specific enough for an agent to understand the core operation, but it does not explicitly differentiate itself from the sibling tool search_epjson_objects, which likely performs a similar name-based search.

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 a helpful use case: 'useful for analyzing all components related to a particular zone, system, or equipment.' However, it does not state when to prefer this tool over alternatives like search_epjson_objects or list_objects_by_type, nor does it mention any exclusions or conditions that would make a different sibling more appropriate.

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