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

With zero annotations, the description carries the full behavioral burden and does substantial work: it discloses non-destructive writes ('Writes a NEW deck'), reporting behavior ('reports per-op substitution counts'), re-validation ('re-validates'), and domain nuance ('last control in SCHEDULE wins'). It leaves failure behavior on validation errors unstated, but the core safety profile 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?

Roughly 40 words across three sentences, front-loaded with the root action and override scope. Every sentence carries distinct information — purpose, behavioral guarantees, and an idiomatic example — with zero filler or repetition of schema content.

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

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

An output schema exists (lightening the return-value burden) and the description covers new-deck semantics, per-op counts, and re-validation. But the overrides parameter — the core input beyond deck_path — is structurally undocumented, and flatten_includes is never mentioned; at 0% schema coverage this is a significant gap for actually constructing a valid call.

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 every parameter needed description-level meaning. The description maps to the overrides param by naming its four op types and implies output_path behavior via 'Writes a NEW deck', but it never explains the shape of overrides entries (fields each op requires), nor flatten_includes, validate, or output_path semantics. Partial compensation, not full.

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

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

Description states a specific verb+resource: 'Clone a deck' with concrete override mechanisms (append_before_end / replace_regex / set_title / insert_after_keyword). It self-differentiates from read-only siblings like validate_deck, summarize_deck, and deck_grep by asserting it 'Writes a NEW deck'.

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 concrete operational guidance: 'Idiomatic rate/BHP change: append a new WCONPROD/WCONINJE via append_before_end (last control in SCHEDULE wins)'. However, it never names alternatives or states when NOT to use this tool versus siblings such as validate_deck or pack_deck, leaving exclusions implicit.

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 only states that the tool compares using compareECL, but does not disclose whether it is read-only, whether it produces a report or exit code, what side effects might occur, or how the comparison outcome is represented.

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

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

The description is a single sentence with no filler, and the core operation is front-loaded. It is appropriately short for a tool whose name already communicates the operation, though it sacrifices substantive detail.

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

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

Given five parameters, zero annotation coverage, and a related sibling tool, the description is not complete enough. It does not explain the meaning of tolerances, the role of keywords, what 'ECL result files' entails, or what output the user should expect. The existence of an output schema mitigates return-value ambiguity but does not fill these gaps.

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

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

The schema description coverage is 0%, so the description must compensate for undocumented parameters. It implies the two file arguments ('two ECL result files') but says nothing about abs_tol, rel_tol, keywords, or how they affect the comparison. This is a significant gap for a 5-parameter tool.

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 ('Compare') and resource ('two ECL result files'), and adds the key constraint 'within tolerances'. It is clear and actionable, though it does not explicitly differentiate from the sibling tool compare_summaries, which is a closely related comparison operation.

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

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

The description gives no guidance about when to use compare_ecl versus alternatives like compare_summaries or compare_to_observed. It neither states the intended context nor rules out other tools, leaving the agent to infer usage from the name alone.

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

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

No annotations are present, so the description carries the safety burden. It exposes the useful behavioral detail that FOPT/FGPT/FWPT/FPR are used by default unless keys are supplied. It does not explicitly state that the operation is read-only, but 'compare' strongly implies it and the output schema covers return shape.

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

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

The description is a single tight sentence with no filler. It front-loads the core action and then gives the exact default behavior, making it easy 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?

The output schema likely explains return values, and the description covers the main input intent. Still, an agent has to infer case identifiers and valid key formats, and the description does not point to list_cases or list_summary_vectors for resolving those values, leaving moderate gaps for a 3-parameter tool.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning to 'keys' by giving the default list and indicating they may be supplied. It does not clarify how case_a/case_b should be specified or whether keys can be a comma-separated string versus an array, though the names are 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 uses a specific verb ('Compare') and a specific resource ('two cases on field totals') and provides the default keys. It is clear enough to distinguish from single-case summary tools, though it does not explicitly name sibling alternatives such as field_summary or compare_to_observed.

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

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

Usage is implied: use this tool when you need to compare two cases on field totals or supplied summary keys. However, there is no explicit guidance about when to prefer this over related tools, nor any stated prerequisites 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?

With no annotations, the description carries the transparency burden. It usefully discloses blank-cell handling, per-key statistics, and an inline overlay plot. However, it does not say whether output_path writes files, whether plot=false suppresses output, or what other 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 compact and front-loaded: the first sentence states the purpose and metrics, and the second paragraph adds the essential CSV contract. There is 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?

Without an output schema, the description should fully define the call contract. It gives a good account of the observed CSV format and return shape at a high level, but three of five parameters are unexplained and the exact stats/plot behavior is underspecified for a no-annotation tool.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It clarifies observed_csv's expected structure and the meaning of keys, but leaves case_path, plot, and output_path undefined, which is a significant gap for a five-parameter tool.

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

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

The description names a specific operation (history-match QC) and the exact metrics (RMSE/bias/MAE/NRMSE) over simulated vs observed data, which is clear. It does not explicitly differentiate this from siblings like compare_summaries or plot_summary, so it stops short of a 5.

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

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

The intended use is implied by 'History-match QC' and the observed-data CSV format, but the description never states when to prefer this tool over alternatives such as compare_summaries, nor does it give exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It does state the core conversion behavior, but it omits side effects such as whether the input file is modified, how a null output_path is handled, or whether existing output files are overwritten. This is partial transparency, not complete.

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

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

The description is a single concise sentence with the action 'Convert' front-loaded. There is no redundant wording, though the brevity comes at the cost of useful parameter and behavior details.

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

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

With three parameters and no annotations, the description is too sparse for reliable invocation. It explains the general conversion purpose but leaves mode semantics and output-path behavior undocumented. The presence of an output schema helps with return values, but it does not fill the parameter and side-effect gaps.

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

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

Schema description coverage is 0%, and the description adds no information about 'mode', 'input_path', or 'output_path'. An agent cannot determine what values 'mode' accepts, what 'auto' means, or the behavior of a null output path, so the description fails to compensate for the undocumented schema.

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

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

The description uses a specific verb ('Convert') and names both the resource ('ECL result files') and the conversion direction ('between formatted (F*) and unformatted'). This clearly distinguishes it from sibling tools like compare_ecl and makes the tool's function immediately understandable.

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 tool when an ECL result file needs to be converted between formatted and unformatted forms. It does not name explicit alternatives or when-not conditions, but no sibling tool appears to offer equivalent conversion functionality, so exclusions are less critical.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does well by explaining that the search resolves the INCLUDE tree, respects $ALIAS paths, returns file/line/context, and skips files larger than ~8 MB while reporting them. It does not mention the max_matches cap or default case-insensitivity, but the core behavioral traits are clearly disclosed.

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

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

The description is compact, front-loaded with the essential behavior, and every sentence adds value: the search scope, the worked example, the return contents, include-file handling, and the large-file skip behavior. No filler or redundant restating of the tool name or schema.

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

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

Given that an output schema exists and the schema defines parameters with defaults, the description is largely complete for an agent to invoke the tool. It covers what the tool returns, how includes are resolved, and an important edge case (large files skipped). The only notable gap is that it does not clarify the interaction between the default max_matches=40 and the claim of returning 'every keyword hit.'

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 adds meaning for pattern (via regex example), context (via context=8 example), deck_path (as the deck), and search_includes (via include-tree traversal). However, it does not explain ignore_case or max_matches beyond what the schema property names already imply, and the phrase 'every keyword hit' is not qualified by max_matches.

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

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

The description states a specific verb and resource: 'Regex search across a deck AND its resolved INCLUDE tree'. It clearly differentiates this tool from siblings like deck_text, summarize_deck, or pack_deck by emphasizing grep-like search behavior, include-tree traversal, and PATHS-awareness. The example makes the purpose concrete.

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 by calling this 'the deck-QC workhorse' and showing a realistic regex query, which implies the tool is for inspecting keyword occurrences during deck validation. It does not explicitly list alternatives or when-not-to-use cases, so it falls short of a 5, but enough context is present for an agent to select it appropriately.

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

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

With no annotations, the description carries the behavioral burden: it discloses the numbered output format, that decks are plain ASCII, that no WSL is needed, and how file matching against the resolved INCLUDE tree works. It stops short of describing edge cases or line-numbering semantics, but the core behavior is transparent.

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

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

Three sentences: main purpose, when to use, and file-parameter behavior. Each sentence adds distinct value and the key behavior is front-loaded.

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

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

The description covers purpose, use case, and include-file selection, and an output schema exists so return details need not be spelled out. However, the under-documented parameters and lack of guidance relative to sibling text/deck tools leave the definition only moderately 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, but only the file parameter is explained in depth. deck_path, n_lines, and start_line are left to their schema titles/defaults, and the description does not clarify their interaction, such as inclusive range or 1-based indexing.

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

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

The opening phrase 'Numbered text slice of a deck (or one of its include files)' clearly names the resource and output form. It does not explicitly contrast with siblings like deck_grep or summarize_deck, though the alternative to host-shell head/sed helps position it.

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 to use this instead of host-shell head/sed when a client misdetects .DATA as binary, which is a concrete when-to-use condition. It does not discuss when not to use it in favor of MCP sibling tools such as deck_grep.

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 what data is included, but does not state whether the tool is read-only, whether the case must already have a run/summary file, or what assumptions it makes about the input. The presence of an output schema mitigates, but does not eliminate, the uncertainty.

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 one compact line with no filler, and the most important qualifier 'Field-level' appears first. It is appropriately sized for a simple tool.

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

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

The tool is simple (one required parameter, output schema available), so the minimal description is partly acceptable. However, the lack of any guidance on case_path or on when to use this tool relative to well_summary and read_summary leaves invocation partially to inference.

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 and the tool description never mentions case_path. The parameter name is somewhat self-explanatory, but the description adds no path format, qualification, or behavior hints to help an agent construct valid input.

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 the delivered result as 'Field-level KPIs' and itemizes the included metrics (cumulative production/injection, pressure, final rates), which makes its purpose clear and differentiates it from well-level or raw-vector tools. It lacks an explicit verb such as 'returns' or 'computes', which prevents a 5.

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

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

There is no statement about when to prefer this tool over well_summary, read_summary, list_summary_vectors, or summary_tool. The word 'Field-level' is the only selection signal, but it is never framed as guidance or contrasted with 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It does not mention whether cancellation is asynchronous, irreversible, requires the job to be in a specific state, or affects logs and artifacts—important considerations for a state-changing 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 a single, front-loaded sentence with no filler. It is concise and immediately parseable while still conveying the core operation.

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

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

The tool is simple, has only one required parameter, and an output schema exists, so the description is close to sufficient. However, it omits cancellation side effects and lifecycle preconditions, which makes it only minimally complete for a state-changing command with 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 provides no parameter description (0% coverage), but the description at least clarifies that job_id refers to a running Flow job. It does not explain how to find the job_id or what values are valid, so it only partially compensates for the missing schema documentation.

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

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

The description states a specific action ('Cancel') on a specific resource ('a running Flow job'), making the tool's purpose immediately clear. It also distinguishes itself from siblings like run_flow and flow_status without needing to read the schema.

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

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

No guidance is provided on when to use this tool versus alternatives, how to obtain a valid job_id, or what preconditions must hold. The description only names the action and target, leaving the agent to infer the entire usage 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?

No annotations are provided, so the description bears the full burden. It does disclose the data source and the reported dimensions, implying a read-only parsing behavior. However, it does not explain behavior when convergence data is missing, how 'wasted steps' or 'worst steps' are defined, or whether the report is derived directly from log output.

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

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

The description is compact and front-loads the key idea: solver performance from INFOSTEP/INFOITER. It wastes no words and briefly enumerates the report contents. It leans toward under-specification, but as a concise summary it is effective.

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

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

Although an output schema exists, the description lacks important context such as when this tool is applicable, what prerequisites are needed, and how it relates to sibling tools. Given two parameters, no annotations, and a specialized report, the description is too minimal to fully support selection and 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?

Schema description coverage is 0%, so the description must compensate for the lack of parameter documentation, but it does not clearly define case_path or worst_n. The phrase 'worst steps' loosely relates to worst_n, but the meaning, units, and effect of the parameter are left implicit. case_path is entirely unexplained.

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

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

The description identifies the specific resource ('solver performance from INFOSTEP/INFOITER') and the content ('time by stage, wasted steps, worst steps'), making it distinguishable from sibling flow/status/log tools. It lacks an explicit verb like 'generate' or 'report', but the intent is clear enough.

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

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

There is no guidance about when to use this tool instead of flow_status, flow_log_tail, or other sibling tools. It also does not mention prerequisites such as the case needing to have been run with Flow or the presence of INFOSTEP/INFOITER output, so an agent must infer the appropriate 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?

No annotations are provided, so the description carries the burden for behavioral disclosure. It communicates that the operation is a read-only listing and adds scope ('known to this server') and recency ('recent'), but it does not clarify recency limits, ordering, or whether listed jobs are active, completed, or historical. This is adequate but not rich.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently captures the action, resource, scope, and recency without 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?

For a zero-parameter listing tool with an output schema present, the description is mostly complete: a model knows what action to invoke and what domain it covers. The main gap is the absence of any pointer to related job-lifecycle tools, which would help with navigation, but that is not essential for a simple list operation.

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

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

The input schema has zero properties, so there are no parameters to document. The description therefore cannot add parameter-level meaning, and the baseline of 4 applies.

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

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

The description states a specific verb ('List'), a clear resource ('recent Flow jobs'), and a scope ('known to this server'). It is easy to tell this apart from sibling tools like flow_status or flow_log_tail because it is about enumerating jobs rather than inspecting a specific job, though it does not name an alternative explicitly.

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

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

The description provides no guidance about when to use this tool versus siblings such as run_flow, flow_status, or flow_cancel. There is no mention of prerequisites, typical flow, or exclusions, so an agent must infer the intended usage from the tool name and the verb 'List'.

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 it does well: it discloses that grep is a case-insensitive regex, filters the WHOLE log first, and returns the last matching lines with line numbers. This is meaningful behavioral information beyond the tool name. It does not discuss errors or permissions, but the read-only nature is reasonably implied by 'Return the tail.'

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

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

The description is compact and front-loaded, with the core purpose stated first and a useful example following. Every sentence earns its place; there is no filler or repetition of schema information.

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

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

For a read-only log-tail tool with an output schema, the description covers the purpose, log scope, grep behavior, and line-number output. The main gap is the lack of any guidance about when to use this tool versus sibling log/status tools, but the core calling semantics are sufficiently 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 explains the non-obvious grep parameter in detail with a concrete example, and the phrase 'last lines matching lines' conveys the role of the lines parameter. job_id is self-explanatory from the tool name and the required field. Some explicit lines-parameter documentation would be nice, but the description adds real semantics where the schema is silent.

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: 'Return the tail of a Flow job's combined stdout/stderr log.' This clearly identifies what the tool does and the 'combined stdout/stderr' detail distinguishes it from status or summary-oriented 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 implies usage for retrieving filtered tail output from a Flow job log and gives a concrete grep example, but it never explicitly states when to prefer this tool over alternatives like flow_status or flow_jobs. There are no exclusions or alternative routing clues beyond the tool name itself.

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

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

With no annotations provided, the description carries the full behavioral burden. It correctly implies a non-mutating read operation through 'Check' and adds the 'latest progress line' detail. It does not disclose error behavior, job ownership requirements, or what happens when a job has completed or failed, making it adequate but not rich.

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

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

One concise sentence that front-loads the action and the returned information. There is no filler, no repetition of the schema, and no unnecessary 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?

For a simple status tool with one parameter and an output schema, this gives the essential purpose. It lacks usage context about when to poll versus using related tools, and it doesn't clarify where job_id comes from, 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?

The schema exposes a single self-explanatory job_id string, and the description ties it to 'a Flow job'. However, it doesn't explain how to obtain the job_id or any format expectations, and schema description coverage is 0%, so the added parameter meaning is minimal.

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

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

The description names a specific action ('Check whether a Flow job is still running') and a concrete output trait ('latest progress line'), so the purpose is clear. It doesn't explicitly contrast with siblings like flow_jobs or flow_log_tail, but the verb+resource makes it identifiable as a status check.

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

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

No guidance is given about when to call this instead of related tools such as flow_jobs, flow_log_tail, or flow_cancel, nor where the job_id should come from. The phrase 'still running' implies polling, but the description never states 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 must carry behavioral disclosure. 'Static grid info' suggests a read-only operation with no side effects, but it does not explicitly state that it does not modify anything or describe any data-source quirks or performance considerations. The behavioral profile is simple enough that this is not a major gap.

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

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

The entire description is one short sentence that front-loads the tool type and immediately lists the specific information returned. 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?

This is a low-complexity tool with a single self-explanatory parameter and an output schema, so the description does not need to explain return structure. However, it omits any usage context, such as prerequisites or relationship to sibling tools, and does not clarify what 'porosity/permeability stats' means precisely. It is minimally adequate but leaves room for better guidance.

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 says nothing about case_path or how it should be provided. The parameter name and type schema give some minimal meaning, but the description fails to add any extra semantic context, such as requiring a path to an existing case or accepting WSL/Windows paths.

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 specifies the resource (grid) and concrete outputs (dimensions, active count, porosity/permeability stats). It is clear but lacks an explicit verb like 'get' or 'retrieve', and it does not explicitly distinguish itself from sibling data-read 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 word 'static' implies this tool is for structural grid metadata rather than dynamic results, but there is no explicit guidance about when to choose this over alternatives such as field_summary or list_wells. No exclusions or alternative tool names 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?

No annotations are present, so the description carries the behavioral disclosure burden. It does disclose determinism and the hashing implementation, and 'compute' implies a non-mutating operation, but it does not state whether the file content or parsed deck is hashed, path expectations, or potential failure modes.

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

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

One sentence that front-loads the verb and the resource, with no filler. Every word contributes meaning, and the deterministic/algorithm detail is valuable without bloating the text.

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

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

For a one-parameter helper with an output schema, the core invocation requirements are met: an agent knows the action to perform, the required input, and that the result is deterministic. The lack of explicit safety or usage context is minor for this simple tool, though annotations could have strengthened it further.

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

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

There is one required parameter, deck_path, with 0% schema description coverage. The description's 'deck' minimally ties the parameter to the tool's purpose, but it doesn't clarify path format, relative/absolute paths, or WSL/Windows path handling, which nearby sibling tools suggest could matter.

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 precise verb ('Compute'), names the resource ('a deck'), and specifies the algorithm ('opmhash') plus determinism. No sibling tool performs hashing, so it is clearly distinguishable from validate_deck, summarize_deck, and the other deck-related tools.

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

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

The description gives no when-to-use or when-not-to-use guidance and names no alternatives. An agent must infer that hashing is for identity/comparison; there is no explicit context such as 'use validate_deck for validity checks instead.'

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

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

With no annotations, the description carries the behavioral burden and mostly meets it: it indicates a read-only scan, enumerates returned fields, and specifies ordering (newest first). It could more explicitly state that it does not modify files, but 'scan' and 'returns' convey non-mutating 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 short, information-dense, and front-loads the core purpose before listing return values. Every sentence earns its place with no filler.

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

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

The description covers the tool's role, return fields, and ordering, which is good for a listing tool. However, it leaves limit and max_depth semantics unexplained, and without annotations or useful schema descriptions it is not fully complete for an agent deciding how to invoke 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%, and the description does not explain limit or max_depth, only implicitly addressing directory. The parameter names and defaults provide some signal, but the description does not compensate for the missing schema documentation.

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 scans a directory tree for simulation cases, identifies the relevant file types (.DATA and .SMSPEC), and lists what it returns. This is specific enough to distinguish list_cases from sibling tools like list_wells or list_summary_vectors.

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?

Calling this 'The session opener' gives clear contextual guidance that it should be used first to discover available cases. It does not explicitly name alternatives or say when not to use it, but the intended role is strongly 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?

There are no annotations, so the description carries the full burden. It does disclose a useful behavioral detail: the optional glob pattern is case-insensitive. However, it does not mention ordering, empty-result behavior, or what happens when the case_path does not exist, though the read-only nature is implied by 'List'.

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 two short, information-dense sentences with no filler. The core operation is front-loaded, and the pattern behavior is stated efficiently in the second sentence.

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

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

For a simple listing tool with an output schema and a small parameter set, the description covers the essential behavior. It falls slightly short on usage differentiation and limit semantics, but it is largely sufficient for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that 'pattern' is a glob and case-insensitive, and 'case_path' is the case being listed. However, it adds nothing about the 'limit' parameter, leaving its semantics to the schema's name and default value.

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

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

The description clearly states the operation ('List'), the resource ('summary vector keys'), and the scope ('in a case'). It is specific enough to distinguish from value-reading siblings like read_summary, though it does not explicitly call out alternatives.

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

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

No guidance is given about when to use this tool versus alternatives such as read_summary, field_summary, or well_summary. The intended use can be inferred from the name and description, but the description itself offers no explicit context 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?

With no annotations provided, the description carries the behavioral disclosure burden. It does clarify that only wells declared at the first schedule step are listed, which is useful behavioral scoping. But it does not mention whether the tool is read-only, how it handles missing or invalid deck paths, or what the returned list format will be.

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

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

A single, front-loaded sentence with no filler. Every word earns its place, and the key scope qualifier 'at the first schedule step' is included without bloat.

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

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

The tool is simple, has one parameter, and an output schema exists, so the description does not need to detail return values. However, the absence of usage alternatives and the lack of any behavioral notes beyond scoping leave moderate gaps for an agent deciding whether this is the right tool.

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

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

Schema description coverage is 0%, and the description does not explain the deck_path parameter beyond implicitly connecting it to 'the deck'. The parameter is simple and self-titled, but the description adds no real semantic value beyond what the schema already states.

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

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

The description names a specific verb ('List') and resource ('wells declared in the deck'), and adds a scope qualifier ('at the first schedule step') that helps distinguish it from generic well-listing operations. It does not explicitly contrast with siblings like well_summary, but the resource and scope are clear enough to infer 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 implies when to use the tool: when you need the set of wells defined in the deck at the initial schedule step. However, it provides no explicit guidance about when not to use it or which sibling tool would be a better fit for dynamic well output or summary data.

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

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

There are no annotations, so the description carries the burden of behavioral disclosure. It usefully explains that default mode 'inline' produces one self-contained deck and that the result should be validated and run. However, it does not disclose whether output_deck writes a file, what non-inline modes do, or any side effects 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 three sentences with no filler. The main purpose is stated first, followed by the core restart relationship, mode behavior, and suggested next steps. Every sentence adds actionable information.

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

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

For a tool with an output schema and a clear workflow, the description covers the essential context: how to find valid steps, what the default mode produces, and what to do with the result. It omits details about output_deck and skiprest, but the core invocation path is sufficiently 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 clarifies the three required parameters by showing the relationship 'restarts base_deck from restart_case:report_step' and explains the default mode. It does not explain skiprest or output_deck beyond their schema defaults, leaving some parameters underdocumented.

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: generate a restart (history -> prediction) deck via OPM's rst_deck. It identifies the key inputs (base_deck, restart_case, report_step) and references related sibling tools, making its purpose distinct from validation or execution tools.

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

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

It gives clear context on when to use this tool: to create a restart deck for predictions, with restart_info as the source for available steps, and validate/run_flow as follow-up steps. It does not explicitly state when not to use it or name an alternative such as clone_deck, but the intended workflow is 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 provided, the description carries the full burden of disclosing side effects and behavior. It does reveal the kind of quantities the tool handles, but it does not state whether the tool is read-only, whether it writes files, which inputs it reads, or how 'exact oil mass-balance drift' is determined.

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 very short and has no filler words, which is good for conciseness. However, it leans too heavily on cryptic abbreviations and omits information an agent needs, so it is under-specified rather than efficiently complete.

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 presence of an output schema lessens the need to describe return values, but the description still lacks parameter guidance, usage context, and behavioral detail. For an agent selecting among a large set of reservoir and simulation tools, this description is not sufficient to use the tool confidently.

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

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

The input schema has one required parameter, case_path, with zero description coverage. The tool description does not mention case_path at all, nor does it clarify what kind of path is expected or how it relates to the material balance calculations.

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

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

The description names the domain ('Field MB QC') and lists specific outputs (OOIP, recovery factor, oil mass-balance drift, surface VRR), which distinguishes it from many sibling tools. However, it lacks an explicit verb such as 'computes', 'checks', or 'reports', and is heavy on acronyms, so the core action is only implied rather than stated.

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

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

The phrase 'Field MB QC' implies this is a field-level material-balance quality check, but the description never states when to use this tool instead of closely related siblings like field_summary, read_summary, or compare_summaries. There is no mention of prerequisites such as having a valid case_path, a completed simulation, or restart data.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It explicitly lists what the tool checks: reachability of wsl.exe, responsiveness of flow and ResInsight, and import success of python3-opm-common bindings. This gives an agent a concrete model of what executing the tool will do.

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

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

The description is compact and front-loaded: the first sentence states the core purpose, and the second expands with concrete examples. Every sentence earns its place without padding 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 zero-parameter diagnostic tool with an output schema, the description is complete. It explains what the tool does, when to use it, and what specific behaviors it checks, so an agent has everything needed to select and 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?

The tool takes zero parameters, so the baseline is 4. The description adds no parameter-specific semantics because none are needed; nothing in the schema or description requires further clarification.

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

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

The description states a specific verb and resource: 'Report which OPM binaries and Python bindings the server can reach.' It also names the concrete targets (wsl.exe, flow, ResInsight, python3-opm-common), which makes its purpose unmistakable and distinct from the sibling workflow tools in this list.

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?

'Use this first when troubleshooting' is an explicit when-to-use instruction that provides clear context. It does not name alternatives or exclusion conditions, but for an environment-probing tool the guidance is sufficiently directional and actionable.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that output is a single file, but does not explain output location, whether files may be overwritten, external command side effects, or failure behavior. This is a significant gap for a tool that creates artifacts.

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

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

The description is a single front-loaded sentence with no filler or repetition. It communicates the core action, target, and result efficiently.

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 no annotations and zero schema description coverage, this is incomplete. An agent is left guessing where the flattened file is written, what output_dir controls, and whether the tool modifies the original deck. The presence of an output schema reduces the need to describe return values, but the missing usage and output-location guidance are still important gaps.

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

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

Schema description coverage is 0%, so the description must compensate, but it adds little parameter-level detail. It indirectly clarifies that deck_path refers to the deck whose INCLUDEs are flattened, but it says nothing about output_dir, its optionality, or its default behavior.

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 ('flatten') with a clear resource ('a deck and all its INCLUDEs') and a concrete result ('into a single file'). It clearly distinguishes pack_deck from sibling tools like validate_deck, summarize_deck, and convert_ecl by naming the exact packaging action.

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

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

No explicit guidance is given about when to use this tool versus alternatives such as clone_deck, convert_ecl, or deck_text. The usage context is only implied by the action word 'flatten', with no when-to-use or when-not-to-use conditions 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 provided, the description carries the full burden, and it delivers: it discloses data source behavior (UNRST vs INIT), default report step behavior, inactive-cell rendering, 1-based axes, and inline output. This is substantial behavioral 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?

Three compact sentences with no redundancy. The core purpose is front-loaded, and each subsequent clause adds useful behavior or usage context.

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

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

The description covers the main axes, layer selection, property families, default report step, inactive-cell handling, and rendering behavior. The main omissions are the roles of vmin/vmax and output_path, which matter for correct invocation but are not severe enough to undermine the tool's overall clarity.

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 explains keyword values (PRESSURE/SWAT/SGAS/SOIL and PORO/PERMX/NTG/PORV), the default report step behavior, and the role of k_layer. However, vmin, vmax, output_path, and case_path are not semantically explained, leaving gaps for several 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 states a specific verb and resource: 'I–J areal map of a grid property for one K layer, rendered inline.' It also distinguishes itself from ResInsight-based tools by calling itself 'the no-GL alternative to a ResInsight view,' so an agent can tell it apart from sibling plotting/visualization tools.

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

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

The description gives clear when-to-use context: dynamic properties from UNRST at a report step versus static properties from INIT, and identifies the QC use case for sweep/depletion. It points to ResInsight as an alternative but does not explicitly enumerate sibling tools or conditions for avoiding 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 supplied, the description carries the behavioral burden and does disclose meaningful traits: output is a PNG rendered inline, keys support wildcards in either array or string form, twin-axis behavior groups by engineering unit, and no ResInsight/OpenGL is needed. It does not mention side effects like writing to output_path or max_points downsampling, but the core behavior is transparent.

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

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

Three sentences cover purpose, parameter quirks, and the tool's niche with no filler. The main purpose is front-loaded, and every sentence contributes new information relevant to invoking the tool correctly.

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 no output schema and no annotations, the description is adequate for basic usage but not complete: it omits behavior of start/end filtering, max_points, and output_path. For a tool with 9 parameters and only 2 required, an agent still has to infer a fair amount about the optional inputs.

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 explains the non-obvious semantics of keys (wildcards, accepted formats), x_axis values, and twin_axis grouping. However, several parameters (start, end, max_points, output_path, title) receive no explanation beyond the schema names/types, leaving gaps for a 9-parameter tool.

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: 'Plot summary vectors to a PNG, rendered inline in the chat.' It also differentiates itself from heavyweight alternatives with 'No ResInsight/OpenGL needed — the fast path for rate/pressure/cumulative plots,' making clear it is a specialized plotting tool rather than a generic viewer.

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 clear context for when the tool is appropriate ('fast path for rate/pressure/cumulative plots', no ResInsight/OpenGL required), which indirectly distinguishes it from ResInsight-based siblings. It lacks an explicit 'use X instead when Y' statement or a named alternative, so it stops short of full when/when-not guidance.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does communicate that this is a read operation, that data is downsampled to max_points, and that keys accept multiple formats. However, it does not describe time-range handling, default behavior, or error cases like invalid keys.

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 minimal and well-structured, front-loading the core behavior in the first sentence and adding only necessary key-format detail in the second. There is no filler or redundant repetition of schema 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?

Although an output schema exists, the description still under-specifies several important parameters: case_path, start, and end are not semantically explained. For a tool with 5 parameters and no annotations, this is not enough for an agent to confidently construct a correct call.

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 for missing parameter documentation. It explains the keys format and ties max_points to downsampling, but case_path, start, and end are left entirely to inference from their names and types.

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

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

The description clearly states a specific action and resource: reading summary vectors as time series with downsampling. It does not explicitly contrast with closely related siblings like list_summary_vectors, compare_summaries, or plot_summary, so differentiation is implied rather than stated.

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

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

There is no guidance about when to use read_summary versus alternatives such as field_summary, well_summary, or plot_summary. The description does not mention exclusions, prerequisites, or routing conditions, leaving the agent to infer usage from the tool name.

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

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

With no annotations, the description carries the behavioral disclosure burden. It explicitly reveals two non-obvious traits: the WSLg dependency and the fact that it returns immediately rather than blocking. It could additionally mention that the GUI remains open after the call returns or error behavior if WSLg is unavailable, but the core behavior is disclosed.

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

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

The description is two short sentences with no filler. The main action is front-loaded, followed by the environment prerequisite and the key return behavior. Every clause adds value.

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

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

For a simple tool with one optional parameter, the description conveys the essential launch behavior, prerequisite, and non-blocking nature. However, it omits any guidance on case_path semantics and does not explicitly distinguish when to choose this tool over resinsight_snapshot or other ResInsight-related tools. This leaves the description usable but incomplete.

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

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

Schema description coverage is 0%, so the description must compensate, but it says nothing about case_path. It does not explain whether case_path is a file path, a project path, whether it is optional for opening an empty GUI, or what path format is expected. The parameter name alone gives only a weak hint.

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

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

The description states a specific verb and resource: 'Open ResInsight as an interactive GUI'. This clearly distinguishes it from siblings like resinsight_snapshot or resinsight_well_log, which imply non-interactive or specialized output modes. The phrase 'interactive GUI' makes the tool's role 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 gives clear context: this opens the interactive GUI, depends on WSLg, and returns immediately, implying it is for launching rather than computing or batch processing. It does not explicitly name alternatives or when-not-to-use conditions, so it stops short of a perfect 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 burden of behavioral disclosure, and it does disclose the main side effect: saving a PNG file to disk. However, it omits other behavioral traits relevant to invocation, such as default output location when output_dir is null, dependency on OpenGL rendering (hinted by the force_software_gl parameter), and potentially long render times.

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

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

A single sentence with no filler: the action verb is front-loaded, the scope is specified ('default 3D view'), and the output is named ('PNG snapshot'). Every word earns its place in fewer than 20 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?

For a tool with 5 parameters and zero annotations, one sentence is insufficient. Missing context includes the meaning of extra_commands, the behavior of output_dir when left null, the role of force_software_gl, and any indication of runtime or environment requirements. The output schema exists, so return-value documentation is not needed, but operational completeness is lacking.

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, but it only loosely maps 'case' to case_path and 'PNG snapshot' to the output. It adds no meaning for view_size, output_dir, extra_commands, or force_software_gl; an agent must guess that view_size is pixel dimensions and has no basis to understand what extra_commands accepts or when force_software_gl is needed.

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

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

The description uses specific verbs ('Render', 'save') and identifies a specific resource: the default 3D view of a ResInsight case, with a concrete output format (PNG snapshot). It is clear enough that an agent would not confuse it with siblings like resinsight_well_log or resinsight_open, though it does not explicitly name or contrast any sibling.

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

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

There is no guidance about when to use this tool versus alternatives such as plot_property_map or resinsight_well_log, and no mention of prerequisites (e.g., a case must be loaded, or ResInsight must be available). The description states what the tool does but provides no usage context, exclusions, or selection criteria.

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

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

No annotations are present, so the description alone must disclose behavior. It indicates a file export side effect, but does not explain whether files are overwritten, whether the output directory is created, whether ResInsight runs headless, or what happens on failure.

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 one efficient sentence with no filler and the key verb is front-loaded. It is somewhat under-specified, but as far as length and structure go it earns its place.

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

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

This is a multi-parameter export tool with no annotations, and the description does not cover required inputs such as case_path or how properties map to LAS curves. Even with an output schema covering the return value, the missing usage context leaves an agent guessing about invocation preconditions.

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 needed to document or at least contextualize the five parameters, but it only implies that 'well' selects one well and that the output is LAS. The optional 'properties', 'output_dir', and 'force_software_gl' parameters receive no explanation.

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 ('Export') and a concrete resource ('an LAS well log for one well'), making the tool's core function clear. It doesn't explicitly differentiate from siblings, but the nearest ResInsight siblings (resinsight_open, resinsight_snapshot, list_wells) are clearly different activities, so an agent can distinguish intent.

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

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

There is no guidance about when to choose this tool over alternatives, nor any stated prerequisites such as needing an opened case or a valid well name. An agent must infer from the tool name and sibling list which scenario calls for 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?

The verb 'List' implies a read-only inspection, and the description states that it extracts report steps and keywords from a UNRST file. However, since no annotations are provided, the description carries the full burden and does not disclose path expectations, error behavior, or whether it only reads the file or also parses additional related files.

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

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

The description is a single focused sentence with no filler. The action and output are front-loaded, making it easy for an agent to quickly parse the tool's core function.

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

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

For a simple listing tool with an output schema, the description is minimally adequate, but it still leaves important gaps: the meaning of case_path in relation to the UNRST file is unexplained, and there is no guidance for choosing this tool over related siblings. The output schema reduces the need to describe return values, but parameter semantics and usage context remain incomplete.

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

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

The schema provides only 'case_path' with no description, and schema description coverage is 0%. The tool description never mentions case_path directly, leaving the agent to infer that the path refers to a UNRST file or a case directory that contains one. The exact relationship between case_path and the target UNRST file is ambiguous.

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

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

The description clearly states the action (List) and the target resource (a UNRST file), and specifies the output content: report steps and keywords. It is specific enough to understand the tool's purpose, but it does not explicitly distinguish itself from the sibling restart_property.

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

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

There is no guidance about when this tool should be preferred over alternatives such as restart_property, nor any mention of prerequisites or exclusions. The intended use is only implied by the description's content, with no explicit when-to-use or when-not-to-use 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?

There are no annotations, so the description carries the full burden. It transparently indicates this is an analysis/read-oriented tool that produces per-layer stats, and it names the supported dynamic properties. However, it does not disclose edge cases, failure modes, or whether any state is modified, though the output schema covers return structure.

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

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

The description is a single concise sentence with no filler or redundant restatement of the tool name. It front-loads the core concept, though the conciseness comes at the cost of omitting useful parameter context.

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

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

The description is too sparse for a 4-parameter tool with no parameter descriptions and no annotations. It does not define what statistics are computed, how the histogram bin count affects results, how report_step is interpreted, or how case_path is used. The output schema helps with return values but not with input semantics.

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 clarify keyword options (PRESSURE/SWAT/SGAS/SOIL) and hints at report_step significance, but n_histogram_bins and case_path are entirely unexplained, and the meaning of 'per-layer stats' is too vague to guide parameter choices.

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

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

The description identifies the resource (dynamic property at a report step) and the produced result (per-layer stats), and names the relevant property kinds. It is not a tautology and is distinguishable from sibling tools like restart_info or plot_property_map, though it lacks an explicit verb.

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

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

No guidance is given about when to choose this tool over alternatives, nor any context about prerequisites such as having a restart file, how report_step interacts with restart data, or when the default behavior is appropriate. Usage must be inferred entirely from the tool name and sibling list.

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

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

With no annotations, the description carries the burden and adds relevant behavior: the data source (CASE.RFT), the WRFTPLT prerequisite, and the 1-based cell indexing convention. It stops short of describing filtering behavior for date/well or failure modes, but the output schema covers return structure.

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

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

Two short paragraphs front-load the core definition and then deliver purpose, prerequisite, and coordinate convention with no filler. Every sentence adds value.

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

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

For a data-retrieval tool with an output schema, the description covers source, purpose, prerequisite, and coordinate convention. The main gap is the meaning and behavior of the optional date/well filters, which are necessary for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate but it only indirectly hints that case_path points to the case, and says nothing about date or well formats, meaning of null, or filtering semantics. The 1-based indexing note refers to returned cell data, not the input 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?

States clearly that the tool returns RFT surveys (pressure vs depth at well connections) from CASE.RFT, and gives the intended QC use case. This is specific enough to distinguish it from sibling data-access tools like read_summary or well_summary.

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

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

Gives an explicit use context (perforation-pressure/gradient QC) and a hard prerequisite (WRFTPLT in the SCHEDULE section). It does not name alternatives or state when not to use the tool, but the context is clear and operational.

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 it does so well: it discloses async execution, immediate job-id return, queueing behavior, default diagnostics writing, and the MPI mode. An agent knows what side effects to expect beyond simply 'run flow.'

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

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

The description is compact and front-loaded: the essential behavior is in the first sentence, and the following sentences add concrete operational details with examples. No redundant text is present.

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 largely complete for launching a job: it covers async behavior, queue limits, diagnostics, and MPI. It does not mention output_dir or threads behavior, but the output schema likely covers return structure. Minor gaps keep it from a perfect score.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain extra_args syntax, mpi_processes, and convergence_info meaningfully. However, threads and output_dir are not described beyond their titles, leaving some ambiguity in a zero-coverage 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 opening sentence, 'Start an OPM Flow simulation in the background; returns a job id immediately,' uses a specific verb and resource and clearly separates this from validation, monitoring, and cancellation siblings. The purpose is unambiguous.

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

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

The description explains the concurrency model (OPM_MCP_MAX_PARALLEL, queued submissions), when convergence output is useful, and how mpi_processes changes invocation. It does not explicitly tell an agent when not to use this tool versus validate_deck or flow_status, but the context is strong enough to infer the right call.

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 'passthrough' plus the shell-style splitting of string args do disclose meaningful behavior. However, it does not cover failure behavior, exit codes, how stdout/stderr are handled, or whether the target binary must already exist in PATH — notable gaps for an execution tool.

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

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

Three short sentences with zero filler. The purpose is front-loaded, and the argument-format note directly follows it, addressing a real ambiguity in the schema. Every sentence earns its place.

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

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

The description is minimally viable for a passthrough runner: the output schema covers return values, and the args/tool semantics are addressed. But the 'etc.' in 'upscale_perm, upscale_relperm, etc.' leaves the set of valid tool values ambiguous, and there is no example invocation or note about environment prerequisites, so an agent may stumble on the first call.

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 meaningfully: it clarifies that args can be a JSON array (each element a positional argument) or a plain string split shell-style, adding semantics the schema's anyOf doesn't convey. It also gives concrete examples for the tool parameter (upscale_perm, upscale_relperm). Only cwd semantics are left to inference, which is largely self-evident.

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 ('Run') and a specific resource ('an opm-upscaling binary'), naming concrete examples like upscale_perm and upscale_relperm. The term 'passthrough' clarifies the execution model. It doesn't explicitly name sibling upscaling_status, but the run-vs-status distinction is reasonably inferable.

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

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

No guidance exists on when to use this tool versus alternatives. There is no mention of upscaling_status (a closely related sibling), no prerequisites such as requiring a WSL-converted path (despite to_wsl_path/to_windows_path siblings), and no exclusions or conditions. The intended context must be inferred entirely.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says what the summary includes; it does not state whether the tool is read-only, whether it requires a valid deck, how it handles errors, or any side effects. This leaves meaningful behavioral gaps for an agent.

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

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

The description is a single, well-structured sentence with a front-loaded main clause and a concise colon-separated list. Every word adds information and there is 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 is adequate for a simple one-parameter tool with an output schema available. However, it lacks usage guidance, parameter semantics, and path-format context, so an agent has to infer important details about when and how to call 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% and the description does not explain deck_path beyond what the parameter name and schema title already imply. It does not clarify path format, expected file type, or the WSL/Windows path considerations hinted at by sibling tools like to_wsl_path and to_windows_path.

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 ('summary') and resource ('deck'), and enumerates the exact content covered: phases, units, grid dimensions, wells, schedule length. It is clear, but it does not explicitly differentiate itself from related sibling tools like validate_deck or grid_info, so it stops short of a 5.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of when a high-level summary is preferred over validate_deck, deck_text, or field_summary, and no exclusions or conditions are stated.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only says the tool runs an OPM CLI command; it does not state whether it is read-only, what side effects exist, how output is produced, or what the returned data represents. The word 'reader' weakly implies non-mutating behavior, but that is not explicit.

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

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

The description is a single front-loaded sentence with no filler, and the core action is stated first. It is genuinely concise, though the brevity sacrifices useful detail that would make the tool more tractable.

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

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

An output schema exists, so return values need not be exhaustively described, but the tool still lacks parameter semantics, usage guidance, and sibling differentiation. Given the large sibling set and zero schema description coverage, this is too incomplete for confident tool selection and 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?

Schema description coverage is 0%, so the description must compensate, but it only hints at case_path via 'on a case.' The keys parameter is entirely unexplained: its format, purpose, relation to summary selection, and behavior when null are not described. This is insufficient for correct invocation.

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

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

The description states a specific action: 'Run the OPM summary CLI on a case,' which identifies the verb, resource, and basic mechanism. The parenthetical 'alternative summary reader' hints at differentiation, but it does not name the sibling tool it is an alternative to, so some ambiguity remains among the many summary-related siblings.

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

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

There is no when-to-use or when-not-to-use guidance. The phrase 'alternative summary reader' vaguely implies a choice over another tool, but no sibling is named and no conditions are provided, making it hard for an agent to decide between this and read_summary, field_summary, well_summary, or other summary tools.

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

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

With no annotations provided, the description carries full behavioral disclosure burden. It states the core conversion behavior clearly, but does not mention valid WSL path formats, handling of relative paths, or potential error cases. For a simple pure conversion this is adequate but not rich.

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

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

A single sentence that is front-loaded with the action and target. Every word earns its place; there is no redundant or filler content.

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

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

For a one-parameter, simple string conversion with an output schema present, the description covers the essential operation. It does not explicitly describe edge cases or route to the inverse sibling, but the low complexity and available output schema make it sufficiently 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%, and the description only repeats the parameter name ('wsl_path') without adding examples, constraints, or format expectations. It does not compensate for the schema's lack of parameter documentation.

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 ('Translate') and resource ('WSL path') with a clear target ('its Windows form'). The word 'back' indicates this is the inverse of a corresponding conversion, which distinguishes it from the sibling to_wsl_path without needing to open the schema.

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

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

The phrase 'back to its Windows form' implies when to use this tool (when you have a WSL path and need Windows format), but it does not explicitly name to_wsl_path as the alternative or state conditions for choosing one over the other. Usage is implied rather than explicitly guided.

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

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

With no annotations provided, the description carries the full behavioral burden. It clearly discloses the core transformation behavior and illustrates it with an example. It does not mention edge cases like UNC paths or invalid input, but for a simple path converter, the stated behavior is transparent.

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

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

The description is a single, focused sentence with an example that adds clarity without any fluff. It is appropriately sized for the tool's simplicity and front-loads the core purpose.

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

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

For a one-parameter conversion utility with an output schema, the description is largely complete and sufficient for an agent to invoke it correctly. It could benefit from an explicit pointer to the inverse tool, but the example and stated purpose cover the essential 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%, but the description's example `C:x` adds context by showing the expected Windows path format. However, the description does not explicitly document parameter constraints, accepted variations, or error conditions, so it only partially compensates for the missing parameter 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 the tool's function with a specific verb and resource: 'Translate a Windows path to its WSL equivalent'. The concrete example `C:\x` → `/mnt/c/x` removes ambiguity and distinguishes it from the inverse sibling `to_windows_path`.

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

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

The intended use case is implied by the purpose statement, but there is no explicit guidance about when to prefer this tool over `to_windows_path` or any other alternative. The description is clear enough for a simple conversion, but it leaves the when-to-use decision to inference.

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

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

With no annotations, the description carries the burden of signaling behavior. 'Detect whether... available' clearly conveys a read-only status check with no mutation or side effects. It does not detail how detection is performed, but for a zero-parameter probe 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?

A single, focused sentence conveys the entire purpose with no filler. Essential information is front-loaded: it detects availability of an optional dependency.

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

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

For a zero-parameter tool with an output schema, the description is complete. An agent can confidently invoke it without further clarification, and the mention of 'optional' provides enough context about why this check matters.

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

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

The tool has no parameters and the schema already documents this fully (100% coverage). The description correctly avoids inventing parameter details, and the zero-parameter baseline of 4 applies.

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

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

The description states a clear action ('Detect'), a specific resource ('optional opm-upscaling binaries'), and the exact question being answered ('are available'). This clearly distinguishes it from sibling tools like run_upscaling, which executes upscaling rather than checking its prerequisites.

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

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

The description implies when to use this tool: before running upscaling, to verify the optional binaries exist. However, it does not explicitly state this or mention any alternative tools, so the usage context is left mostly to inference.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does state the action and output, but it does not explicitly confirm the operation is read-only, explain how parser issues are surfaced, or describe behavior on invalid or missing deck paths.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently conveys the action, the target resource, and the expected result.

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

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

For a one-parameter tool with an output schema, the description covers the essential purpose and usage. It is not fully complete because it lacks guidance on choosing between this and similar tools, and it does not confirm side-effect-free behavior, but a capable agent could likely 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?

The single parameter, deck_path, is self-explanatory by name, and the description adds that it refers to an ECLIPSE/Flow DATA deck. However, with 0% schema description coverage, there is no further detail about path format, required extensions, or expected input types.

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

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

The description uses a specific verb ('Parse') and identifies the resource ('ECLIPSE/Flow DATA deck') and output ('keyword counts + parser issues'). It clearly communicates what the tool does, though it does not explicitly contrast it with similar siblings like summarize_deck.

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

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

The description gives no guidance about when to use validate_deck instead of alternatives such as summarize_deck, deck_grep, or deck_text. There are no exclusions, prerequisites, or explicit context cues to help an agent pick this tool over its siblings.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does reveal the core behavior — returning per-well KPI values — but it does not mention units, time range, calculation basis, read-only nature, or error behavior. This is minimally adequate but leaves material gaps.

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

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

The description is a single compact sentence that front-loads the scope ('per-well') and then lists the key output fields efficiently. There is no filler, redundancy, or unnecessary 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 output schema presumably covers the return shape, but invocation context is incomplete: 'case_path' is unexplained, and no guidance distinguishes this tool from the many related summary and well tools. For a two-parameter tool with no annotations, the description should do more.

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 for the two required parameters. It does not explain 'case_path' at all, and 'well' is only indirectly implied by 'per-well.' An agent has almost no semantic grounding for how to fill these arguments correctly.

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 produces per-well KPIs and enumerates the key output categories: oil/gas/water rates, BHP, and cumulative production. The 'per-well' scope helps distinguish it from field-level tools like field_summary, though it lacks an explicit verb such as 'get' or 'return.'

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 instead of related siblings such as read_summary, list_wells, field_summary, or compare_summaries. There are no exclusions, prerequisites, or alternative-selection cues beyond the vague 'per-well' signal.

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