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 thoroughly discloses the algorithm (numpy.roots), the output structure (roots table, real/complex factors, damping, frequency, period, standard errors), and explicitly states that 'INTERPRETATION IS LEFT TO THE ASSISTANT.' It also references external matching tools (ABTreadway-Dperar2.xls / caracterizar_operadores.py), giving confidence in behavior. It is transparent about both the mechanics and the intended use of results.

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 dense but well-structured, starting with a one-sentence purpose followed by clear technical and interpretation paragraphs, then parameters. It front-loads the main verb and resource. While longer than strictly necessary, every sentence adds value and no content is redundant. The structure aids scanning.

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 explains the purpose, algorithm, output details, and parameter semantics. It does not specify the exact return format (e.g., JSON structure) or potential error cases, but since no output schema is provided, it describes the results sufficiently. The interpretation guidance and context of feeding into MEG/Shin-Fuller tests complete the picture, making it robust for a complex analytical 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 coverage is 0%, so the description fully compensates. It explains both parameters: 'inp_path : path to .inp or .pre file (fitted model)' and 'sper : seasonal period; 0 (default) uses the series frequency.' This adds meaning beyond the bare schema types and gives concrete guidance on what each parameter does.

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: 'Factorize the estimated AR operator(s) of a fitted model and identify candidate seasonal AR_f factors.' This clearly distinguishes the tool from siblings like seasonal_analysis or unit_root_analysis by focusing on AR factorization and detecting hidden seasonal factors. It fully answers what the tool does.

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

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

The description explains the intended context: 'a complex factor whose period matches a seasonal cycle ... is a candidate seasonal AR_f operator ... to feed the MEG (DCD_f) and the dual Shin-Fuller AR_f test.' This tells the assistant when to use the tool (when a fitted model might contain hidden seasonal factors). It does not explicitly name alternatives or when not to use it, but the context is sufficiently clear.

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

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

With no annotations, the description carries the full burden. It discloses that the tool saves individual .inp files and HTML diagnosis reports, returns a summary table and figures, and that run_meg is slow. It also notes that it is an 'Autonomous pipeline'. It does not cover edge cases like overwriting behavior or error handling, but for a batch wrapper, this is adequate.

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

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

The description is front-loaded with a one-sentence purpose summary, followed by a compact parameter list. There is no redundant information, and every sentence adds value. It is appropriately sized for the tool's complexity.

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

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

The tool has no output schema, so the description must explain return values, which it does: 'Returns a summary table and individual diagnosis figures.' It also covers the pipeline behavior, file outputs, and parameters. It lacks details on error handling or failure modes, but for a batch tool with 4 well-explained parameters, it is complete enough for 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 has 0% description coverage, but the description provides clear semantics for all four parameters: inp_paths as source .inp paths, output_dir as the save directory, max_rounds with a default of 5, and run_meg with a default of False and a note that it is slow. This fully compensates for the missing schema descriptions.

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

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

The description clearly states the tool's function: 'Autonomous pipeline for multiple series. Builds one model per series.' It distinguishes itself from the sibling tool build_model by explicitly saying it 'Calls build_model for each inp_path', making it evident this is the batch counterpart.

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 context is clear: this tool is for processing multiple series, as implied by 'Autonomous pipeline for multiple series' and 'Calls build_model for each inp_path'. It references the alternative build_model for single-series use, but doesn't explicitly state 'use this when you have multiple series' or provide exclusion criteria. Still, the guidance is strong enough for an agent to infer when to choose 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool computes mean-std scatter for lambda=0 and lambda=1, recommends a transformation, and returns a comparison figure. As an analysis tool, this is transparent about its core behavior, though it does not comment on side effects or file requirements beyond the inp_path parameter.

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 reasonably concise, with a clear purpose statement, a useful differentiation note, and a parameter list. It is front-loaded with the main purpose and the note is not wasted. The length is appropriate for the information conveyed.

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 low complexity (1 param, no output schema, no annotations), the description covers the purpose, usage context, parameter, and expected output (comparison figure). It does not specify prerequisites like file existence or format, but overall it is sufficient for an agent to select and invoke the tool correctly.

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

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

The schema has one parameter with no description, and coverage is 0%. The description adds 'path to the .inp file' to clarify the parameter's meaning, which is helpful but minimal. It does not explain the .inp file format or expected contents, but for a single-parameter tool this is adequate.

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 'Analyse Box-Cox transformation for a time series (standalone use)' with a specific verb and resource. It also explicitly distinguishes itself from the sibling guided_identification by noting its standalone scope and what the guided alternative does instead.

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 explicit guidance: 'in guided analysis use guided_identification instead' and explains the alternative's integrated workflow. This tells the agent exactly when to choose this tool versus the alternative, leaving no ambiguity.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool runs a single engine, iteratively re-estimates with intervention additions, stops after 'clean diagnosis or max_rounds', and 'Always returns parameters + residual diagnosis figure; DCD/MEG at the end.' It also reveals side effects: writes to output_path and records to guion_path. Missing are failure modes, performance expectations (except run_meg slow), and explicit permission needs, but overall it is fairly 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: a clear opening purpose, a bulleted mode explanation, a 'returns' line, and a parameter list. It is longer than average, but the length is justified by 15 parameters and the need to explain two modes. The combined 'd, D' line introduces slight ambiguity, preventing a perfect score.

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

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

Given the tool's complexity (15 params, no annotations, no output schema), the description is highly complete. It explains the pipeline flow, mode selection, parameter sentinels, and return values, and even sequences it after guided_identification. Minor gaps: the d/D distinction is not explicit, and no alternatives or exclusions are mentioned, which would push it to a 5.

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 0% description coverage, but the description's parameter section explains all 15 parameters with sentinel meanings (e.g., '-1 = let the heuristic decide'), allowed values (lam 0/0.5/1, decision A/B1/B2), and roles (inp_path source, output_path final .inp, guion fields for recording). This far exceeds the schema's bare type/default information and fully compensates for the lack of schema descriptions.

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

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

The description clearly states the tool runs a 'Box-Jenkins-Treadway pipeline for a single series' and details the iterative process: deciding the spec, estimating, adding interventions for outliers, and re-estimating until clean or max_rounds. It distinguishes modes (autonomous vs guided) and references 'guided_identification' as a precursor, which differentiates it from siblings. The verb 'build' and resource 'model' are specific.

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

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

The description gives explicit guidance: use guided mode 'after guided_identification to run the build with the confirmed spec while the outlier cycle proceeds automatically.' It also explains when the heuristic decides (autonomous) vs when analyst choices are honored (guided). However, it does not name alternative tools or state when not to use this tool, which would make it a 5.

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

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

With no annotations provided, the description carries the full transparency burden. It explicitly discloses behaviors: 'Loads and fits both .inp files', returns a comparison figure, mentions the nested LR test condition, and notes that guion_path is 'unused currently, reserved'. This adds significant context beyond the schema, though it does not explicitly state whether any files are modified or side effects occur.

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 and front-loaded. The first line states the purpose, followed by a clear bulleted list of return items and a compact parameter table. Every sentence contributes meaningful information, and the 'reserved' note avoids confusion. No unnecessary verbosity.

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

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

The tool is complex (compares two models with multiple outputs), and no output schema exists, so the description appropriately explains return values and parameter semantics. It covers the main functionality, including the conditional LR test and figure generation. However, it does not mention potential error conditions (e.g., invalid .inp files) or prerequisites beyond fitting the files, so it is not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It includes a detailed Parameters section explaining each parameter: inp_path_a, inp_path_b, lam_a, lam_b, guion_path, with meanings and defaults (e.g., 'lam_a: Box-Cox lambda for model A (0.0 = log)'). This fully compensates for the schema's lack of descriptions.

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

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

The description clearly states the tool's function: 'Compare two estimated models' with specific outputs (spec diff, stats table, nested LR test). It identifies the specific resources (.inp files) and scope, which distinguishes it from sibling tools like estimate_and_diagnose or model_histogram.

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

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

The description implies usage by stating 'Compare two estimated models' and listing the return items, but it does not explicitly say when to use this tool versus alternatives (e.g., record_version or estimate_and_diagnose). It provides context but lacks explicit exclusions or alternative references.

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

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

The description discloses return values in detail ('Always returns' list), side effects of incremental mode (loads interventions/harmonics from .pre, replaces only ARMA part), and even warns about a known bug (BUG-0005 spurious Nyquist) with workaround for seasonal parameters. No annotations were present, so the description carries the full burden and does so thoroughly.

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

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

The description is front-loaded with the core action, followed by a structured breakdown of modes, returns, and parameter details. Though long, it is necessary given 20 parameters, and each sentence adds operational value. The use of headings and bolded parameter names improves scannability.

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 20 parameters, no output schema, and no annotations, the description provides comprehensive context: what it builds, how the two modes differ, what is returned, and detailed parameter semantics including bug workarounds. It is more than sufficient for an agent to correctly select and invoke this 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?

With schema_description_coverage at 0%, the description compensates fully. Every parameter is explained with its meaning, default, and special cases (e.g., 'lam: Box-Cox lambda (0.0=log, 1.0=identity)', 'seasonal: None (default) => derive from n_harmonics>0', 'base_pre_path: if given, load interventions+harmonics...'). This provides value far beyond the schema.

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

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

The description opens with a specific action: 'Build the .inp for the confirmed spec, estimate and show diagnosis immediately.' It clearly distinguishes from siblings by explaining two modes (fresh vs incremental) and referencing the typical use case 'final ARMA step after outlier cycle'. The scope is well-defined.

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

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

Explicit usage guidance is provided: it describes when to use each mode (base_pre_path empty vs provided), states 'Use this to add ARMA to a model after the outlier cycle', and advises on include_histogram ('Keep False during the outlier cycle... set True for the final model only'). It also explains when to set estimate_mu based on statistical evidence.

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 explains that the produced .inp is a 'minimal data container (no model structure)' and lists the return value. However, it omits potential behavioral details like whether existing files are overwritten, whether directories are created, or how invalid data is handled. This is adequate 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 well-structured with a one-line summary, a usage paragraph, a clear parameter list, and a returns section. Every part is informative and necessary, with no wasted words.

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

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

The description covers all six parameters with explanations, provides usage context relative to the entire guided workflow, and defines the return value. For a file-creation tool of this complexity, it is fully complete even without the output schema.

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

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

Schema description coverage is 0%, and the description fully compensates by detailing every parameter with examples and valid values (e.g., freq mapping 1=annual, 4=quarterly, 12=monthly). This adds substantial 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 the tool's function: 'Create a .inp file from raw time series data.' It also explicitly marks it as the FIRST tool to call for spreadsheet/CSV data, distinguishing it from siblings that handle existing .inp files or later workflow steps.

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 specifies when to use the tool: 'when the user provides data from a spreadsheet, CSV, or any source other than an existing .inp file.' This effectively includes an exclusion for existing .inp files, but it does not explicitly name alternative tools, so it falls just short of a 5.

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

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

With no annotations, the description discloses the estimation method (MVENC maximum likelihood), the exact diagnostic tests run, and the side effects of output_path (writes .pre and .out files, default is screen-only). This goes beyond basic safety but does not mention error handling or prerequisites.

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

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

The description is structured with a leading action sentence, a behavior paragraph, and a clear parameter list. Every sentence adds value, and it is not overly 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?

The tool has moderate complexity, no annotations, no output schema, and a sparse schema. While input and side effects are well explained, the return value is never stated—it is unclear whether the function returns diagnostic results, the fitted model, or nothing. This is a key 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?

Despite schema having no descriptions, the description explains inp_path as the model specification file and output_path in detail (persist .pre/.out, default behavior). Both parameters are fully covered with context beyond their 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 fits a model from an .inp file and runs a full diagnosis, listing specific tests (standardised residuals, ACF/PACF, Ljung-Box, Jarque-Bera, seasonality). This distinguishes it from sibling tools by combining estimation and diagnosis in one step.

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 explicitly state when to use this tool versus alternatives like confirm_and_estimate. It implies this is a 'clean path' and mentions that output_path mirrors confirm_and_estimate's file trio, but gives no direct guidance or exclusions.

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

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

Since no annotations are provided, the description carries the full burden. It details what the HTML report includes (summary table, collapsible sections), but does not disclose side effects like overwriting output_html, required file format for guion.json, or error behavior. It is not misleading, but it lacks depth on behavioral traits.

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

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

The description is concise and well-structured with a summary sentence, a bulleted list of generated content, and a clear Parameters section. Every sentence adds value, with no waste or repetition.

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 tool with two string parameters and no output schema, the description covers the essential aspects: input, output file, and report contents. It does not explain return values, but since the tool generates a file, that is implied. Minor gap: no mention of what happens if the output file already exists.

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 explicitly defines guion_path as 'path to guion.json' and output_html as 'path to write the .html file', adding semantic meaning beyond the bare schema properties. While brief, it clearly explains the purpose of each parameter.

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

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

The description clearly states 'Render guion.json to a self-contained, navigable HTML report' with a specific verb (render) and resource (guion.json), and elaborates on the output contents. This distinguishes it from sibling tools like full_report or save_identification_report.

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 guidance on when to use this tool versus alternatives. No mention of similar tools like full_report or save_identification_report, and no exclusions or prerequisites. The user is left to infer that this tool is for exporting a standalone HTML report.

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 transparency burden. It discloses the hypotheses tested, critical values, and the computational cost of MEG ('slow'), as well as a precondition for MEG (D=0 + harmonics). It does not state side effects, but for a test tool this is acceptable.

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

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

The description is well-structured with a clear first sentence, a bulleted list of tests, and a parameter section. Each test description adds essential context, and parameter explanations are concise. No waste.

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 complex tool with no output schema, the description omits what the tool returns (e.g., a report, p-values, a model object). It also lacks broader prerequisites beyond MEG's D=0 condition. The test list is thorough, but the output aspect remains a 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 must explain parameters. It does: inp_path is 'path to .inp or .pre file' and run_meg is 'whether to run MEG (slow, default True)'. This fully compensates for the missing schema descriptions.

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

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

The description clearly states the tool 'Run formal hypothesis tests on a fitted model' and enumerates the specific tests performed (Shin-Fuller, DCD, DCD_f, RV, MEG). This distinguishes it from sibling tools that focus on single tests or broader model actions.

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 clear context: to be used on a fitted model, with tests applied 'where applicable to the model structure.' It does not explicitly mention alternatives, but the context is sufficient for an agent to decide when to run this compared to more specialized sibling tools.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It discloses the output format (self-contained HTML), the sections, and the conditional MEG behavior, but omits file-handling details such as whether the output file will be overwritten, required permissions, or prerequisites beyond a 'fitted model.' This is adequate but has clear 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 well-structured and front-loaded: a one-sentence purpose, a numbered list of report sections, and a concise parameter table. Every sentence serves a purpose; there is no redundant or unnecessary 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's complexity (four parameters, multiple report sections) and the existence of an output schema, the description covers the essential functionality well. It mentions all sections and parameter details. Minor omissions—such as overwrite behavior or computational cost—prevent a perfect score, but overall it is sufficiently complete for an agent to invoke correctly.

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

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

The schema description coverage is 0%, but the tool description compensates thoroughly by explaining each parameter: inp_path and output_path with path types, run_meg with a condition (only if D=0 + harmonics), and intervention_threshold with the mathematical meaning (|z| threshold). This adds significant value 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 'Generate a complete HTML report for a fitted model and save it to disk,' which is a specific verb+resource+scoped action. The section list (estimated model, diagnosis, formal tests, interventions) distinguishes this from sibling tools like 'formal_tests' or 'estimate_and_diagnose' by presenting itself as the all-in-one report generator.

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 for a fitted model and produces a comprehensive, self-contained HTML report, implying use when a full report is needed. However, it does not explicitly mention alternatives or exclusions, such as when to use specialized tools like 'formal_tests' instead, so it stops short of a 5.

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

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

With no annotations, the description must disclose behavior. It explains the sequence (load model, compute forecasts, write files) but does not mention side effects like overwriting existing files, required permissions, or whether the input model is modified. The process is described, but there is room for more disclosure.

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

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

The description is well-structured: a concise summary paragraph followed by a parameter list with clear explanations. It is front-loaded with the core purpose, and every sentence earns its place without redundancy.

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

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

Given there is no output schema and no annotations, the description is largely complete. It covers the inputs, outputs, and the role of each file. It lacks explicit mention of behaviors like overwriting or directory creation, but overall it provides enough context for an agent to use the tool appropriately.

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. It explains each parameter in detail (e.g., inp_path is a fitted .pre file, horizon is the number of periods ahead, output_fuf_path is for update_and_forecast, output_html is required). This adds substantial meaning beyond the schema's property 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 generates L-step-ahead forecasts from a fitted model, and lists the two output artifacts (fuf file and HTML report). This is a specific verb+resource, and the mention of writing a fuf file for update_and_forecast distinguishes it from 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?

The description provides clear context: use this when you have a fitted model and need forecasts, and it produces both a fuf file for future updates and an HTML report. It does not explicitly name alternatives or state when not to use it, but the context is sufficient.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add context by specifying the exact contents of the report and noting it produces the same output as the C 'fue' binary. However, it does not explicitly state prerequisites (e.g., the model must already be estimated, no side effects) or clarify whether the tool modifies any files. This is a moderate gap for a retrieval-like 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 concise and well-structured: it opens with the primary action, then lists the output contents, provides a usage context sentence, and ends with a clearly labelled parameter section. Every sentence adds value without redundancy, making it easy for an agent to parse quickly.

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 and no annotations, the description does a good job of explaining what the report contains (parameter estimates, AIC/BIC, residual statistics, etc.) and when to use it. It is not an overly complex tool, but it could be improved by explicitly stating the return format (e.g., ASCII text as a string) and any error conditions. Still, it is complete enough for an agent to invoke successfully.

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 provides the parameter name `inp_path` with a string type, giving no description. The tool description compensates by explaining: 'inp_path : path to the .inp or .pre file with the model specification.' This adds critical semantic meaning, clarifying the file types and purpose. It could have gone further with path format examples or absolute/relative path guidance, but it meets the need for this 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 opens with a specific verb+resource: 'Return the full fue .out ASCII report for an estimated model.' It clearly states the tool's function and distinguishes it from sibling tools like `estimate_and_diagnose` and `model_equation_display` by emphasizing the complete ASCII report containing detailed output such as parameter estimates, AR/MA polynomials, and residual statistics.

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

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

The description provides clear context: 'Useful for detailed review of the estimated model beyond what the diagnosis summary shows.' This indicates when to use the tool—when a deeper, more complete report is needed rather than just a summary. It does not explicitly name alternatives or state when not to use it, so it falls short of a 5, but the guidance is clear enough.

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 tool's interactive nature through repeated 'WAIT for user,' its stateful flow via lam/d/D/pre_path parameters, and the B1/B2 branching logic. This goes beyond a simple action description, though it still omits explicit detail about return formats or side effects.

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

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

The description is lengthy and includes a complete decision tree, but it is well-structured with sections and front-loaded with the core concept. Some repetition (e.g., 'WAIT for user') could be trimmed to improve conciseness, but each paragraph adds necessary procedural 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?

The description covers the full decision tree, parameter semantics, and references to related tools (unit_root_analysis, confirm_and_estimate, etc.), making it quite complete for a complex interactive tool. However, it doesn't describe the output schema or return values explicitly, relying on the user to know what 'Box-Cox scatter' or 'ACF/PACF' entail.

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 includes a dedicated Parameters section explaining each parameter's meaning and default sentinel values (-1), and how pre_path is used in Call 4 B1. This fully compensates for the 0% schema coverage, providing rich semantics that the 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 clearly states 'Sequential identification — ONE decision node per call' and outlines a multi-step decision tree, which distinguishes it as a guided, interactive identification tool. However, it doesn't explicitly contrast with sibling tools like identification_analysis, so the purpose is clear but not fully differentiated.

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

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

The description provides a detailed call sequence and mentions 'Support: unit_root_analysis available if needed,' giving some context on when to use this tool. However, it lacks explicit when-to-use vs. alternatives like boxcox_analysis or seasonal_analysis, and doesn't say when not to use this tool.

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

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

With no annotations provided, the description carries the full burden. It discloses the core behavior (compares empirical ACF/PACF with theoretical, returns top-5 suggestions) and adds context like 'series is used, model spec ignored' and the internal call relationship with guided_identification. It does not explicitly state side effects, but for an analysis tool this is reasonably transparent.

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

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

The description is well-structured with a clear main statement, a note block, and a parameter list. It is slightly verbose in the note section, but every part contributes useful information. The front-loaded purpose and usage guidance make it easy to scan.

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

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

Given the tool's moderate complexity and absence of an output schema, the description is quite complete. It explains the input file handling, parameter meanings, the algorithm (comparison of ACF/PACF), and the return (top-5 suggestions). It could further detail the output format, but the core information for an agent to select and invoke the tool 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 compensate. It does so fully by explaining each parameter: inp_path, d (regular differencing), D (seasonal differencing), and lam (Box-Cox with 0=log, 1=identity), including defaults. This goes well beyond the bare schema and resolves potential ambiguity.

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

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

The description clearly states the tool's function: 'ACF/PACF identification listing + ARMA order suggestions'. It uses a specific verb ('compares', 'returns') and identifies the resource (differenced series). It also distinguishes itself from the sibling tool 'guided_identification' by explicitly marking this as standalone vs. guided use.

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 explicit when-to-use guidance: 'standalone use' and directs users to 'guided_identification' for guided analysis. It even outlines the specific call sequence for the guided alternative, giving clear context and exclusion criteria.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It transparently lists what the tool reports (e.g., extreme dates, variance fraction, affected lags, test reliability), but does not explicitly state whether it is read-only or if it modifies inputs. It also does not mention thresholds for flagging beyond the parameter, though the output list gives a clear sense of behavior.

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

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

The description is well-organized with a one-line summary, a bulleted output list, and a parameters section. It contains no redundant text, though the output list is slightly long. Overall, every sentence contributes to understanding the tool's purpose and behavior.

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 diagnostic tool with no output schema, the description covers the main outputs and parameters effectively, listing exactly what will be reported. It lacks explicit statement of return format (e.g., console output vs. file) and does not explain whether the analysis is performed on an existing model or solely on the input file, but the core behavior is well documented.

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 adds substantial meaning beyond the schema: it specifies that inp_path points to a .inp or .pre file and defines threshold as the |z| cutoff with a default of 3.5. This directly explains each parameter's purpose and format, compensating for the schema's lack of property descriptions.

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

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

The description opens with a specific verb and resource: 'Detect extreme residuals and assess their impact on ACF/PACF and tests.' This clearly states the tool's function and differentiates it from sibling tools like preliminary_outlier_scan (which likely scans raw data rather than residuals) and test_interventions (which likely tests intervention significance). The enumerated output items further clarify the scope.

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

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

The description does not explicitly state when to use this tool versus alternatives. It mentions 'residuals' which implies post-estimation, but there is no clear guidance on prerequisites, when an intervention analysis is needed, or which sibling tools (e.g., preliminary_outlier_scan) to use instead. The user must infer usage from the 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, the description does explain the file output and the auto-detection behavior for date indices. However, it omits important behavioral details such as whether existing files are overwritten, what happens on errors, and what the function returns. This is minimal transparency for a file-writing 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: a concise one-line summary, a behavioral note about date index inference, and a parameter list. Every sentence provides useful information, and the format is easy to scan. The minor typo 'fue' does not detract from overall conciseness.

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

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

The description covers all parameters and the core behavior, but lacks information about return values and error handling. Since there is no output schema, the description should explain what the tool returns after writing the file. It also doesn't mention potential side effects like file overwriting, leaving some gaps for a tool with 8 parameters and no annotations.

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

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

The schema has 0% description coverage, but the tool description thoroughly documents every parameter with added meaning: column can be exact name or integer index, freq meanings (1=annual, 4=quarterly, 12=monthly), default for series_name, etc. This fully compensates for the schema's lack of descriptions.

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

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

The description clearly states the tool loads a time series from Excel/CSV and writes an .inp file, which is a specific verb+resource+outcome. However, it does not explicitly distinguish this from sibling tools like create_inp, so it lacks clear sibling differentiation.

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 explains when parameters must be supplied (date index vs manual) but not when this tool should be chosen over sibling tools. There are no exclusions or alternative references.

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 and delivers a detailed behavioral account: what is kept from the baseline, how the AR_f unit root is reformulated, how the LR is computed, the decision rule (LR > crit ⇒ stochastic, LR ≤ crit ⇒ deterministic), and the invertibility flip of the witness coefficient. This goes far beyond a generic 'runs a test' and fully discloses internal 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 long but dense and technically justified. It front-loads the core purpose, then structures the mechanism, decision rule, and parameters in clear sections. Every sentence adds meaningful information—there is no redundancy or filler, and the Parameters list makes lookup easy.

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 the tool's high complexity and absence of annotations or output schema, the description is complete: it explains the statistical context, the contrast with alternatives, the interpretation of results, the exact behavior of the engine, and the decision flow. A user can understand what happens before, during, and after invocation without needing external documentation.

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 0% description coverage and only type/title/required info, but the description's Parameters section fully compensates. It explains `inp_path` (source data plus model fallback), `freq` (1..s/2 range and meaning), and `base_pre_path` (baseline .pre, empty means use inp_path), adding critical semantic meaning not inferable from the schema.

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

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

The description clearly states a specific action: 'MEG for ONE given seasonal frequency, evaluated on the CHAINED baseline.' It distinguishes itself from the sibling `formal_tests` by explicitly noting that this tool tests exactly one frequency instead of sweeping all frequencies, and also references `meg_reformulate` for subsequent adoption, giving a precise scope.

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

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

It provides explicit differentiation from `formal_tests` ('Unlike formal_tests ... this runs ... for exactly one frequency'), making the appropriate use case clear. It does not explicitly state 'do not use for sweeping all frequencies' beyond the contrast, but the implication is strong. It also explains when `base_pre_path` can be empty, which is a practical usage condition.

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 that the tool 'writes the reformulated .pre/.out to output_path', 're-estimates', and 'shows the model equation + diagnosis'. It also explains the behavioral difference between with_witness=True and False, including the consequence of over-differencing (inflated sigma, exploded Q-test). A minor gap is that it does not explicitly warn about overwriting existing output files, but overall transparency is strong.

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 longer than average, but the complexity of the tool justifies the length. It is well-structured: an opening definition, then a detailed explanation of the two modes, iterative guidance, and a parameter list. While not as terse as the highest-caliber examples, every sentence adds value and the structure is logical.

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, the lack of output schema, and no annotations, the description is remarkably complete. It explains the prerequisite (MEG conclusion), the underlying math (AR_f unit root, MA_f witness), the output side effects, and the intended follow-up workflow (formal_tests). This fully equips 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?

With 0% schema description coverage, the description must explain each parameter. It does so in a dedicated Parameters section, covering inp_path, freq, output_path, base_pre_path, and with_witness with meaningful context (e.g., 'ifadf[freq]=1', 'the free invertible MA_f testigo'). This goes far 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 opens with a specific verb-resource combination: 'Reformulate the model for STOCHASTIC seasonality at frequency `freq`' and immediately ties it to the MEG workflow, distinguishing it from sibling tools like formal_tests or identification_analysis. The scope is clear 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 explicitly states when to use the tool ('after the MEG... has concluded stochastic there'), provides clear guidance on the with_witness parameter ('Use it only to inspect the bare over-differenced residuals' for False), and, for multiple stochastic frequencies, instructs to 'call iteratively (strongest first)'. It also references the next step (`formal_tests'), giving full contextual usage.

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 explains the output format (two equations with parameters and standard errors), which is helpful, but it does not disclose whether the tool has side effects, requires special permissions, or handles invalid inputs. For a display tool, the read-only nature is implied but not stated.

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

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

The description is well-structured with headings and equations, and it provides necessary detail without excessive fluff. It could be slightly more concise, but it is organized and front-loaded with the main purpose.

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

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

The description is reasonably complete for a display tool with a single parameter. It explains the output equation forms and the input file type. Since there is no output schema, the description adequately covers return behavior. Minor gaps include error handling and prerequisites, but these are not critical for a read-only display 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?

The description adds substantial meaning to the single parameter beyond the schema's bare type definition. It specifies that inp_path is a path to a .inp or .pre file containing the estimated model, providing file format and purpose that the schema omits.

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 displays the estimated model as two polynomial-operator equations, using a specific verb (display) and resource (model equations). It distinguishes itself from sibling tools by focusing on the B-J-T equation form, which none of the other tools mention.

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

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

The description implies usage when you have an estimated model in a .inp or .pre file, but it does not explicitly state when to use this tool versus alternatives. No exclusions or alternative tool mentions are provided, so usage context is only implied.

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

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

No annotations are present, so the description carries the full burden for behavioral disclosure. It only says 'show' a histogram, with no detail on side effects, prerequisites, return behavior, or whether this is a read-only operation. The phrase 'for a fitted model' hints at a prerequisite, but it is not explicit. Minimal insight beyond the core purpose.

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

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

The description is front-loaded with the core purpose, followed by a concise usage note and a single parameter explanation. Every sentence is relevant, and the structure is clear with a dedicated parameter section. No fluff or redundancy.

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

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

For a simple tool with one parameter and no annotations, the description covers purpose, usage, and parameter semantics well. It could be slightly more complete by explicitly stating prerequisites (e.g., must have an already fitted model) and what the output is (e.g., a plot object or file), but the core context is sufficient for a simple plotting 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?

The schema description coverage is 0%, but the description includes a Parameters section explaining inp_path as 'path to the .inp or .pre file with the estimated model.' This adds meaningful context beyond the schema's bare string type, fully compensating for the missing schema 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 uses a specific verb and resource: 'Show the residuals histogram with normal overlay for a fitted model.' It clearly states what the tool does and distinguishes it from the basic diagnostic module (estimate_and_diagnose / confirm_and_estimate) by emphasizing it is a separate, explicitly requested complement.

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

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

The description explicitly says this is an optional complement to the basic Treadway diagnostic module, names the alternative tools, and states when to request it explicitly: 'when you want to inspect the distributional shape of the residuals.' This provides clear when-to-use guidance and alternatives.

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

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

With no annotations, the description carries the full burden and does well by disclosing the heatmap output, the highlighting of the ARMA/mu block, and the distinction between structural and true redundancy. However, it does not explicitly state whether the tool modifies any files or is strictly read-only, though 'check' and 'shown' imply it.

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 summary, behavioral details, usage instructions, and parameter list. Every sentence adds value, and the length is appropriate for the tool's complexity without redundancy.

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

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

The description covers the workflow (when to run), the behavioral output (heatmap and list), and interpretation (structural vs. true redundancy). However, without an output schema, it does not specify the exact programmatic return structure, though it gives enough for a user to understand what to expect.

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 provides zero description coverage, but the description compensates fully with a dedicated Parameters section explaining the .inp/.pre file path and the threshold default of 0.7. Both parameters are clearly documented, exceeding the schema's bare type information.

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

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

Clearly states the tool checks for overparameterization by inspecting the parameter correlation matrix. The verb 'check' and the resource 'parameter correlation matrix' are specific, and the detailed description of the heatmap and flagged pairs distinguishes it from sibling diagnostic 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?

Explicitly instructs when to run the tool: after estimate_and_diagnose if the diagnosis mentions 'sobreparametrización', or as a routine check before finalizing the model. This gives clear timing and even a conditional trigger, satisfying the dimension.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool returns a standardized series with ±2σ bands and outliers marked, plus a recommendation. It also explains the rationale (outlier treatment before identification). It stops short of discussing side effects or limitations, but for a scanning/analysis tool this is reasonably transparent.

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

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

The description is front-loaded with the main purpose and includes a structured Parameters section. The Spanish phrase 'Lo más obvio primero' adds flavor but is not strictly necessary. Overall, it's efficient and organized, with no redundant repetition of schema info.

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 (5 params, no output schema, no annotations), the description covers purpose, when to use, parameter meanings, and output content. It doesn't include edge cases or error conditions, but for a preliminary scan tool it is sufficiently complete 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 parameters, and it does. Each parameter is given a concise definition: inp_path as the .inp file, d and D as confirmed differencing orders, lam as Box-Cox lambda with examples, and threshold with a default. This adds substantial 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 states a specific verb ('scan') and resource ('differenced series') and clearly distinguishes its role as a preliminary step before ARMA order selection. It also names the output (standardised series with outlier marks and recommendation), which clarifies its purpose relative to siblings like identification_analysis and intervention_analysis.

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

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

It explicitly says 'BEFORE choosing ARMA orders' and explains why (outliers distort ACF/PACF). It also gives a decision-relevant recommendation on adding interventions before identification. While it doesn't name alternative tools, the timing and context are unambiguous enough for an agent to know when to invoke 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 burden. It discloses what the tool does: lists sheets, column names, row count, date range, and frequency, and that it detects date parsing. The word 'preview' implies a read-only operation, but the description does not explicitly state that no modifications occur or mention any permissions. Still, the behavioral output is clearly 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 and well-structured: a one-sentence purpose, a bullet-style list of output details, a clear usage directive, and a compact parameter list. Every sentence adds value, and the most important information (what it does and when to use it) is front-loaded. There is no redundancy or 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 simple tool with only two parameters and no output schema, the description covers the essential aspects: what it previews, what information it returns (sheets, columns, rows, date range, frequency), and parameter details. It also contextualizes itself relative to load_data. It could optionally describe the exact return format (e.g., a dictionary), but the listed outputs suffice for an agent to anticipate the tool's behavior.

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

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

Schema description coverage is 0%, so the description must fully compensate. It does so with a Parameters section: source_path is defined as a path to .xlsx, .xls, or .csv, and sheet is described as 'sheet name (Excel only; default = first sheet).' This adds critical meaning beyond the bare schema titles 'Source Path' and 'Sheet,' making the parameters self-explanatory.

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 begins with a clear, specific statement of purpose: 'Preview the contents of an Excel or CSV file before loading.' It then enumerates the exact outputs (sheets, column names, number of rows, date range, frequency) and explicitly distinguishes itself from load_data by saying 'Use this before load_data.' This fully differentiates it from 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?

The description explicitly tells the user when to use the tool: 'Use this before load_data to choose the right column and confirm that dates are parsed correctly.' This names the associated alternative and provides a concrete use case. However, it does not mention when NOT to use it, or any other alternatives, so it falls short of a full 5.

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

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

With no annotations, the description carries the full burden. It transparently discloses side effects: creates guion.json if absent, appends an entry, and extracts specific stats (loglik, AIC, BIC, etc.). It also notes auto-assignment of 'name' if empty. While it omits error handling and permissions, the core behaviors are made explicitly visible.

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: a high-level summary followed by a bulleted parameter list. Every line contributes useful information, and there's no fluff. It is slightly longer than necessary, but the structure makes it easy to scan.

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

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

The description covers the workflow and all parameters, but there is no output schema and the description does not mention what the tool returns (e.g., a success message, written entry, or stats summary). It also lacks explicit prerequisites or error conditions. For a tool with 7 parameters and no output schema, this is a noticeable gap, keeping it at a 3.

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. The 'Parameters' section provides a one-line explanation for each of the 7 parameters, adding meaning beyond the bare schema titles. For example, 'name' is described as 'version name, e.g. "PC3"; auto-assigned ("PC{n}") if empty.' This is helpful but not deeply detailed, so a 4 is appropriate.

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

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

The description opens with a specific verb+resource: 'Load, fit and record a model version in guion.json.' It then details the exact sequence (load from inp_path, fit, extract stats, append entry) and distinguishes itself from sibling tools like export_guion (export) and compare_versions (compare). This makes the tool's purpose unmistakable.

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 workflow: after having an .inp file, you load, fit, and record. However, it does not explicitly state when to prefer this tool over alternatives, nor does it mention any exclusions (e.g., 'use only when you need to persist a version'). The usage context is clear but unstated as a 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose the key side-effect of writing a file to disk and adds useful nuances such as the differencing orders and the fact that the model spec is ignored. However, it does not mention whether the output file will be overwritten, what happens on error, or whether any prerequisites (e.g., data must be loaded) exist. This is a moderate gap given the lack of annotation support.

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

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

The description is well-structured, opening with a clear, front-loaded purpose statement followed by a brief content summary and then a formatted parameter list. It avoids unnecessary prose and each line adds information. The parameter list slightly duplicates schema information but earns its place by adding explanatory context, so no redundancy is wasted.

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 an output schema exists, the description need not explain return values, and the omission is fine. It covers the report contents, all parameters with semantics, and key behavioral notes like the differencing orders and model-spec handling. It lacks explicit prereq conditions or file-handling behavior, but for a save-report tool this is acceptable. It is more complete than many tool descriptions, though not exhaustive.

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

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

The description's Parameters section adds substantial meaning beyond the input schema. It explains each parameter's role (e.g., 'inp_path: path to the .inp file', 'd: regular differencing order') and provides specific value interpretations ('lam: 0.0=log, 1.0=identity'). Since the schema only lists names, types, and defaults with no descriptions, the parameter semantics are fully compensated by the 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 clearly states that the tool 'Generate and save a full HTML identification report to disk.' It specifies the exact resource (HTML identification report) and the action (generate and save), distinguishing it from sibling tools that focus on analysis or estimation rather than producing a report file. Additional details about the report's contents (ACF/PACF listing and top-5 ARMA order suggestions) reinforce its purpose.

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

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

The description provides clear context by specifying the report type and the parameters, including the note that 'series is used, model spec ignored.' While it does not explicitly name alternatives or state when not to use it, the purpose is distinct enough that an agent can infer when to invoke this tool—when a saved HTML identification report is needed. It stops short of giving explicit 'use this instead of X' guidance, so it does not earn a 5.

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

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

The description explains the statistical method (joint F-test with HAC Newey-West standard errors) and the output (seasonality plot and D recommendation). However, with no annotations provided, it does not disclose whether the tool writes files, requires permissions, or has other side effects, leaving the safety profile incomplete for a support 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 and front-loaded with the core purpose, followed by a usage note and a parameter list. There is minor redundancy in repeating 'support tool', but every sentence adds functional or contextual 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 tool with one parameter and no output schema, the description adequately covers what it does, when to use it, and how to pass the input. It also situates the tool in the workflow (after identification listing), which is helpful context. Lacks detail on output format, but the direct output statement covers the key return value.

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 provides only a required string parameter named inp_path with no description. The description compensates by specifying it is a 'path to the .inp file', adding the file type and implicit purpose. This is sufficient for the single simple parameter, though it does not detail the file's contents or format.

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+resource: 'HAC F-test for seasonal patterns', clearly stating the tool's function. It also immediately distinguishes itself from guided analysis by naming guided_identification as the alternative, making it distinct from 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?

The description explicitly states it is a 'support tool, standalone use only' and provides a direct alternative: 'in guided analysis use guided_identification instead'. It also gives context about being called internally after the identification listing, which tells the agent exactly when to invoke 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?

Without annotations, the description carries the burden of disclosing behavior. It clearly states the tool 'visualises' and 'reports' coefficients, SE, t-ratios, and significance, implying a read-only analysis. It also describes the bar chart output. However, it does not explicitly confirm it makes no modifications or handle edge cases, so it falls slightly short of full transparency.

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 and appropriately detailed: a clear one-sentence purpose, bulleted list of outputs, figure description, and parameter definition. Every sentence earns its place without being verbose.

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

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

The description covers what the tool does, the exact outputs (coefficients, SE, t-ratio, amplitude, significance), and the input parameter. With no output schema, this is sufficient for a visualisation tool, but it lacks guidance on prerequisites or potential error conditions like models without seasonal components.

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%, but the description includes a 'Parameters' section explaining that inp_path is 'path to a fitted .inp or .pre file'. This adds meaning beyond the schema's bare string type and fully compensates for the lack of schema descriptions.

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

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

The description starts with 'Visualise estimated seasonal harmonic parameters (cos/sin) with ±2 SE bars', providing a specific verb and resource with distinguishing detail. It clearly differentiates from siblings like 'seasonal_analysis' or 'test_seasonal_simplification' by focusing on harmonic parameter coefficients.

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 it is used after fitting a model with seasonal components (referring to 'harmonics present in the model' and 'fitted .inp or .pre file'), but it does not explicitly state when to use this tool over alternatives or mention exclusions. No sibling tools are referenced.

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

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

With no annotations, the description carries the burden of disclosure. It states it loads and returns information, implying a read-only operation, but does not explicitly confirm it has no side effects or mention error handling. The return metadata list is useful but lacks depth about behavior edge cases.

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 two main sentences plus a parameter definition. It is front-loaded with the core purpose and avoids extraneous details, though the parameter description could be integrated more cleanly.

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 tool with one parameter and a provided output schema, the description covers the input and the nature of the output (metadata list). It does not mention error scenarios or file prerequisites, but these are minor for an info retrieval tool.

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

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

Schema coverage is 0%, so the description must compensate. It explains 'inp_path' as 'path to the .inp file', which adds meaning beyond the schema's bare property name 'Inp Path'. This adequately clarifies 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 clearly states the verb 'Load' and the resource '.inp file', and specifies that it returns basic information. While it doesn't explicitly name sibling tools, the focus on loading from a specific file type and returning metadata distinguishes it from generic load/preview 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 implies usage for inspecting an .inp file's metadata, but does not provide explicit guidance on when to use it versus alternatives like load_data or preview_data. No exclusions or alternative tool references are given.

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

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

With no annotations, the description carries the full burden. It outlines the main operations (scanning, generating, writing) but does not disclose side effects such as overwriting existing files in output_dir or whether output_dir must pre-exist. This is a moderate disclosure, lacking some behavioral depth.

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 summary, process details, and a parameter list. It is efficient but contains potential typos ('fuf' and 'fue') that slightly detract from clarity. Otherwise, no waste.

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 with 2 simple parameters and no annotations, the description covers the core workflow and parameter semantics adequately. However, it omits the return value (if any) and does not mention whether output_dir is created automatically, which would make it more 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%, but the description compensates fully by explaining both parameters: sps_dir is the directory containing .inp files, and output_dir is where reports and index.html go. This adds clear meaning beyond the schema's title-only fields.

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 generates a sequential prediction (SPS) dashboard for all series in a directory, with a specific workflow (scan .inp files, generate HTML reports, write index.html). This distinguishes it from sibling tools like generate_forecast or full_report.

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

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

The description clearly indicates this tool is for batch processing all series in a directory, implying it should be used when you need a collective dashboard rather than a single-series report. However, it does not explicitly name alternatives or state 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, the description carries the full disclosure burden. It reveals that the tool writes to output_path, auto-selects the most extreme residual when date is empty, and that form='auto' is a heuristic. It also notes the token-saving behavior of include_histogram, making the side effects and trade-offs visible.

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

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

The opening summary is clear, and the parameter explanations are valuable. However, the description is somewhat long due to the redundant duplication of parameter names from the schema, though this is mitigated by the semantic additions. It is well-structured with sections.

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 complex tool with 12 parameters, no output schema, and no annotations, the description adequately explains inputs, outputs, and usage. It mentions the return value (updated parameter table and diagnosis) and the iteration workflow. Minor gaps remain, such as whether the original .inp is modified or only a new file is written, but the overall context is sufficient.

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

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

The schema has 0% description coverage, but the description includes a full parameter list explaining each argument, including accepted formats for date ('MM/YYYY' or 'QN/YYYY' or 'YYYY'), the meaning of 'form', and the purpose of guion_* fields. This fully compensates for the schema's lack of descriptions.

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

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

The description clearly states the tool's function: 'Adds a pulse, step or ramp intervention at the given date, saves to output_path, re-estimates and returns the updated parameter table and diagnosis.' It uses a specific verb with the .inp resource and distinguishes it from sibling tools by noting it is used iteratively, one intervention at a time.

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 instructs to 'Use this iteratively — one intervention at a time,' which provides clear usage context. It also gives timing guidance for include_histogram ('set True for final round'), but it does not compare against sibling tools like intervention_analysis or test_interventions, so no exclusions are stated.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals the statistical tests performed (t-test on each omega, Wald joint test for transfer functions), the exclusions, and the significance threshold via alpha. It does not detail return formats or side effects, but the statistical behavior is well covered.

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

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

The description is front-loaded with a one-sentence summary, followed by concise explanatory bullets and a clear parameter section. No sentences are wasted, and the structure makes it easy to scan. It is appropriately sized for the tool's complexity.

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

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

The tool has two simple parameters and no output schema, but the description provides enough context for correct invocation: it states the input file type, the significance threshold, and the purpose of the test. A minor gap is the lack of explicit information about the return value, but the description implies a list of non-significant interventions.

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, and it does: it explains inp_path as a path to a fitted .inp or .pre file, and alpha as the significance level for classification with a default of 0.05. This adds meaning beyond the raw schema and fully clarifies both 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 opens with a precise statement: 'Test H₀: ω=0 for every non-structural intervention in a fitted model.' This clearly identifies the action (testing) and the target (non-structural interventions), and distinguishes it from sibling tools like intervention_analysis or formal_tests. It also explicitly notes which interventions are excluded, reinforcing its specific scope.

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

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

The description states when to use the tool: to identify non-significant interventions that can be removed to simplify the model. It also clarifies that structural interventions are skipped by default, giving a clear boundary. However, it does not explicitly name alternative tools or state when not to use it, 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 the full burden. It discloses the statistical model being fit (restricted model with harmonics fixed to zero), the test statistic formula, degrees of freedom, and interpretation critera. It does not explicitly state whether the tool writes results to disk or purely returns a value, but the name and context imply a read-only test. The statistical detail is substantial and 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 sections for definition, computation, workflow, and parameters. It is moderately long but every sentence adds value—the formula is essential, the workflow is actionable, and the parameter list is clear. No filler or redundancy.

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

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

The description covers purpose, methodology, workflow, and all parameters. The only gap is that it does not explicitly describe the return value structure (e.g., whether it returns a p-value, LR statistic, or a decision). Since there is no output schema, the description should ideally state what the tool returns. The interpretation guidance makes this implicit but not fully explicit.

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, and it does thoroughly. The Parameters section clearly explains inp_path ('path to a fitted .inp or .pre file'), freq_list ('harmonic indices to test', with the default behavior 'None = test all harmonics jointly'), and alpha ('significance level (default 0.05)'). The workflow also adds practical meaning to freq_list by telling users to pass t-value-selected harmonics.

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 'Joint LR test for eliminating seasonal harmonics: H₀: cos_k = sin_k = 0.' This is a specific verb (test) plus resource (seasonal harmonics) and clearly states the null hypothesis. It distinguishes itself from sibling tools by focusing on simplification testing and explicitly referencing seasonal_param_analysis as the preceding workflow step.

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 explicit workflow guidance: 'Typical workflow after seasonal_param_analysis' and then gives concrete instructions on which frequencies to pass (k values with |t| ≤ 2) and how to interpret the result (remove vs. keep harmonics). This clearly tells the agent when to use this tool and what to do with its output.

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?

In the absence of annotations, the description discloses important behavioral traits: it is a support tool, exploratory, and not a formal hypothesis test. This effectively conveys its role and limitations, though it does not describe output structure or side effects, which are less critical for an analysis 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 reasonably concise, with a clear purpose statement, usage note, and parameter list. The repetition about being a support tool could be tightened, but each sentence contributes useful information without excessive verbosity.

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

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

For a tool without an output schema, the description covers its purpose, position in the workflow, parameter semantics, and key limitations. It could benefit from a brief mention of what the test results look like, but overall it provides sufficient context for an agent to understand when and how to use it.

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

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 all three parameters: inp_path (path to .inp file), lam (Box-Cox lambda with specified values), and max_d (highest differencing order). This adds meaningful context 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 the tool performs ADF + KPSS unit root tests across d = 0 to max_d for selecting the starting differencing order. It also distinguishes itself from sibling tools by explicitly naming guided_identification as the primary tool and formal_tests for formal hypothesis testing.

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

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

Provides explicit usage guidance: it is a support tool called internally after identification listing, not to be used directly in guided analysis; and it is exploratory, not formal, with an explicit alternative (formal_tests) for formal testing.

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

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

With no annotations, the description carries the full burden. It discloses key behaviors: it overwrites fuf_path by default via output_fuf_path, writes to output_html, and reports tracking errors. It does not mention authentication or rate limits, but the destructive default (overwriting) is clearly stated, adding valuable context beyond the schema.

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

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

The description is well-structured: a one-line summary, a process explanation, and a parameter list. Every sentence provides useful information, with no fluff. The parameter section is compact yet informative. It is appropriately sized for the tool's complexity.

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

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

The tool involves updating files and generating reports, and the description covers the workflow, parameter defaults, and output paths. No output schema exists, but the description explains the produced artifacts and behavior. It is complete enough for an agent to invoke correctly without additional context.

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 each parameter: fuf_path ('existing fuf .inp file'), new_values ('list of new observations in original scale'), output_html (required), output_fuf_path ('default: overwrites fuf_path'), and actual_dates ('MM/YYYY' format). This is precisely the semantics missing from the 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 clearly states the tool's function: 'Append new observations to a fuf file and update the forecast.' It also details the process (loads fuf, appends values, re-runs forecast, reports tracking errors, writes HTML). This distinguishes it from siblings like generate_forecast, which creates new forecasts.

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

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

The description implies usage context: it is for updating an existing fuf file with new observations, and fuf_path is described as 'from generate_forecast'. However, it does not explicitly state when not to use it or name alternative tools for similar scenarios. The context is clear enough for an agent to decide.

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