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

No annotations are provided, so the description carries the full behavioral burden, and it says nothing: not what state is mutated, whether the operand is appended or inserted (beyond the schema's insertAt), whether permissions or an existing configuration are required, or whether the change is reversible.

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 single sentence is short and front-loaded, but it is not concise in the useful sense — it is under-specified. It contains no wasted words because it contains almost no content at all.

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 5-parameter mutation tool with no annotations and no output schema, a five-word description is wholly inadequate. Nothing tells the agent how to call it correctly or what the effect of a successful call will be.

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 100%, so all five parameters are already documented in the schema, which sets the baseline at 3. The description adds no parameter detail (nothing about valid operandType values, what param1-3 mean per operand type, or insertAt semantics), so it neither helps nor hurts.

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?

"Add an MCE operand" essentially restates the tool name (add + configuration operand); the only new information is that MCE means the multi-configuration editor. It makes no attempt to distinguish itself from the near-identical sibling zemax_mce_add_operand, or from zemax_add_operand (merit-function operands), which is exactly the ambiguity an agent must resolve.

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 guidance, no prerequisites, and no routing versus zemax_mce_add_operand, zemax_add_operand, or zemax_mce_add_config. The agent is left to guess whether a configuration must already exist or whether an alternative tool is the correct one.

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 does not state whether the catalog is loaded from disk or generated, whether it requires the file to exist, what happens if the catalog is already added, or what the return is. 'Add' implies mutation, but no side effects or state changes are described.

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

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

The description is a single, short, front-loaded sentence with no wasted words. It directly states the action and target.

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 mutation tool with no annotations, no output schema, and no described side effects, the description is insufficient. It should explain what adding a catalog entails (e.g., it becomes available for glass selection), whether it modifies the current system, and any prerequisites. As is, it leaves the agent with only the schema and tool name.

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 100% (the single parameter 'catalogName' is described as 'Material catalog name without the .agf extension'). The description adds no additional parameter information, but with one parameter and full schema coverage, a baseline of 4 is appropriate for zero additional need.

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+resource: 'Add a material catalog to the current optical system.' This is precise and distinguishes the tool from its direct sibling zemax_remove_material_catalog and other catalog tools like zemax_get_glass_catalogs or zemax_export_glass_catalog.

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 when-to-use guidance is provided. The description does not say when to add a catalog versus when to use existing catalogs, or what conditions require this action. It also does not mention the alternative (zemax_remove_material_catalog) or refer to any prerequisite.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states that an operand is added, but does not disclose validation behavior, duplicate handling, persistence, or any required permissions/connection state. This is minimal mutation disclosure only.

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 single sentence is front-loaded and free of filler. It is appropriately terse, though it offers no structural aids for navigating the 12-parameter complexity.

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

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

This is a 12-parameter mutation tool with no annotations and no output schema, yet the description is only one sentence. It does not explain valid operand mnemonics, insert behavior, defaults, or how to discover operands via siblings, leaving the definition inadequate for the tool's complexity.

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 100%, so the schema already documents all 12 parameters, even if many descriptions are generic. The description adds no parameter-level meaning beyond the schema, which is the baseline 3 when structured fields carry the load.

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 gives a specific verb ("Add") and resource ("optimization operand") plus the context that it is added to the merit function. It clearly distinguishes the core action from read/remove tools, but it does not explicitly differentiate itself from close siblings like zemax_add_configuration_operand or zemax_mce_add_operand.

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 on when to use this tool versus alternatives, nor are there prerequisites such as needing an open system or connected session. The intended use is only implied by the phrase "merit function."

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

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

No annotations are provided, so the description must carry the full behavioral burden. It states that a surface is inserted but does not disclose side effects, permissions required, reversibility, or whether an active Zemax session is needed.

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 wasted words. It is appropriately sized for a simple insertion tool, though its brevity contributes to gaps in other dimensions.

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 five-parameter mutation tool with no annotations and no output schema, the description is too thin. It omits usage context, behavioral details, and any indication of prerequisites or return behavior, leaving critical context unstated.

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 100%, so the schema fully documents all five parameters. The description adds no additional meaning beyond what the schema already provides, making the baseline score of 3 appropriate.

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

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

States a specific verb ('Insert') and resource ('a new sequential surface'), and the qualifier 'sequential' distinguishes it from non-sequential siblings like zemax_nsc_add_object and zemax_nsc_insert_object. However, it does not differentiate itself from other sequential insertion tools such as zemax_lde_insert_surface or zemax_lde_set_surface.

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. The word 'sequential' implies a context, but there is no explicit when/when-not or mention of sibling tools like zemax_lde_insert_surface.

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 must disclose behavior. It mentions decimated curves but doesn't explain what 'series' means (e.g., parameter sweeps), what the output structure is, performance implications, or any side effects. The omission of key behavioral context is significant for an analysis tool.

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

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

The description is a single, concise sentence that front-loads the action and result. It could be slightly more informative without becoming verbose, but efficiency is good.

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

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

Given the complexity of series analysis and the lack of annotations or output schema, the description is insufficient. It doesn't clarify what 'series' entails, what inputs are needed beyond analysisType, or what the output looks like, leaving critical gaps for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so parameters are fully documented in the schema. The description adds no parameter-specific details beyond the schema, which is acceptable given the baseline of 3 when coverage is high.

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 verb ('Run') and resource ('arbitrary series analysis'), indicating an analysis-runner. However, it doesn't distinguish from sibling tools like zemax_run_analysis or the many specialized analysis tools (zemax_fft_mtf, zemax_ray_fan, etc.), leaving ambiguity about when this general series runner is preferred over specific analyzers.

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 the numerous analysis-specific siblings. A user must infer that it's for series analyses not covered by dedicated tools, but this is not 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 provided, so the description carries the full behavioral burden, yet it is a single terse sentence. It discloses nothing about return values, whether a lens/system must be loaded first, error behavior for malformed rays, or any connection requirements.

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

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

The single sentence is front-loaded and free of filler, but its brevity reflects under-specification rather than efficient conciseness for a 4-parameter ray-tracing 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?

With no annotations, no output schema, and a domain-specific tool, the description is far too thin. It omits what is returned, whether an open Zemax instance is required, and how the batch input is interpreted or validated.

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 100%, so the schema already documents every parameter including the [Hx,Hy,Px,Py] format and the -1 image convention. The description adds no syntax or format meaning beyond what the schema provides, so the baseline 3 is appropriate.

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

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

States a specific verb (trace) and resource (batch of normalized sequential rays), and the word 'sequential' meaningfully distinguishes it from the non-sequential siblings like zemax_nsc_ray_trace. However, it never explicitly references the sibling it most overlaps with (zemax_ray_trace), so the agent must infer the batch-vs-single distinction.

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

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

No guidance on when to use this over zemax_ray_trace or zemax_nsc_ray_trace. The description never states the context or conditions that select batch tracing, nor any prerequisites such as an open system or active connection.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Calculate' implies a read-only computation, but the description does not say whether it acts on the currently loaded system, requires an active connection/file, or how the wavelength selection affects results. This leaves significant gaps for a tool with zero annotation coverage.

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 efficient sentence with the key output types front-loaded. Slightly under-specified rather than bloated, and 'other cardinal points' is a touch vague, keeping it from a 5.

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

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

With no output schema and no annotations, the description should do more heavy lifting. It lists the main outputs but omits preconditions (loaded system, active connection) and does not indicate the return format, leaving the agent to infer how to call and interpret the result.

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

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

Schema description coverage is 100% and the single wavelength parameter is documented in the schema. The description adds nothing about the parameter (e.g., that the wavelength number indexes the system's wavelength list), so the baseline of 3 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?

States a specific verb (Calculate) and resource (cardinal points) with examples of what is returned: focal lengths, principal planes. An agent can distinguish this analysis from siblings like zemax_seidel_coefficients or zemax_rms_spot. However, it does not name or contrast with any sibling explicitly, 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives. The agent is not told when cardinal-point analysis is the right choice versus other first-order or aberration analyses in the sibling set.

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 and falls short: it does not say the tool is a read-only analysis, what system state it requires, or what happens if only one wavelength is configured. It adds essentially no behavioral context beyond the one-line purpose.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though its brevity leaves little room for the usage and behavioral context an agent would need.

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 parameterless analysis tool with no annotations and no output schema, the description covers the minimum but omits what the result looks like (shift values vs wavelength) and the preconditions for a meaningful run. It is adequate but leaves clear 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 tool takes zero parameters, so there are no parameter semantics to document and the baseline of 4 applies. Nothing in the description misrepresents the (empty) input contract.

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

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

States a specific verb (Calculate) and a precise analysis quantity (longitudinal chromatic focal shift vs wavelength), which clearly identifies the tool's function. It does not, however, distinguish itself from closely related siblings such as zemax_lateral_color or zemax_longitudinal_aberration.

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 on when to run this analysis versus the many related aberration/color analyses in the sibling list. No prerequisites (e.g. multiple wavelengths must be defined in the system) or alternative tools are mentioned, leaving usage 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?

No annotations are provided, so the description carries the full behavioral disclosure burden. It usefully states that the application connection is retained, which is a meaningful side-effect distinction. However, it omits other consequential behavior such as whether unsaved changes are discarded when save is false and whether the closing action is reversible.

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 wasted words. The scoping detail about retaining the connection is included efficiently in the same 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 one-parameter close operation with no output schema, the description covers the core action and the key connection-retention behavior. It is nearly complete, though slightly more context on usage alternatives or unsaved-change behavior would make it fully self-contained.

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 100%, so the single 'save' parameter is already documented in the schema. The description does not add any syntax, default, or side-effect details about the parameter, which is the expected baseline when the schema already covers it.

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 gives a specific verb-resource pair: 'Close the current optical system.' It also distinguishes the action from disconnecting by stating the application connection is retained, which separates it from sibling tools such as zemax_disconnect and zemax_new_system.

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 'while retaining the application connection' implies the intended context: close the current model without terminating the session. However, it does not explicitly state when to choose this over zemax_save_file, zemax_open_file, zemax_new_system, or zemax_disconnect, so alternates are left to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the modes but does not state whether this must be called before other tools, what happens if a connection already exists, whether the connection persists, or if a disconnect is required afterward.

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 wasted words. It is appropriately sized for a simple connection tool and immediately communicates the core action.

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 connection tool with no annotations, no output schema, and no usage guidance, the description is too sparse. It omits essential context such as the connection lifecycle, prerequisites for calling other tools, and what the connection enables.

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 100%, so the schema already documents both parameters. The description repeats the mode options but adds no extra meaning or syntax beyond what the schema provides, which sets the baseline at 3.

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 verb ("Connect") and resource ("OpticStudio"), and specifies the available modes. It is specific enough for an agent to understand the operation, but it does not distinguish itself from siblings like zemax_disconnect or zemax_status beyond the obvious connection semantics.

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

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

The description gives no guidance on when to use this tool versus alternatives, when not to use it, or what prerequisites are needed. It also does not explain which mode to choose in which situation, leaving the agent to infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it says nothing beyond the tool name. It does not state that optimization mutates the system (variables/merit function), whether runs are long or blocking, what happens on non-convergence, or whether prior state is recoverable. This is a significant gap for a state-mutating operation.

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

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

It is a single front-loaded sentence with no padding, but at the cost of under-specification rather than true efficiency — there is room for a clause on when to choose this over zemax_optimize without bloat. Concise but too sparse to be useful.

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

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

With no annotations, no output schema, and a mutation-heavy operation, the description should explain at least what state is affected and when to prefer it over the sibling optimizers. As written it is inadequate for an agent to invoke 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?

Schema description coverage is 100% and all five numeric tuning parameters (delta, initialMu, maxRestarts, maxIterations, useBroydenUpdate) are documented in the schema itself. The description adds no meaning beyond the schema, which is the expected baseline when the schema does the heavy lifting.

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 ('Run') and a specific optimizer ('custom bound-constrained Levenberg-Marquardt'), which is more precise than a generic 'optimize'. However, it offers no differentiation from the many sibling optimizers (zemax_optimize, zemax_multistart_optimize, zemax_hammer, zemax_global_search), so an agent cannot tell this apart from them without guessing.

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 of when to use this optimizer versus the numerous sibling optimization tools, nor any preconditions (e.g. a merit function must exist, variables must be defined). The single sentence gives no routing guidance at all.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Delete' implies a destructive, likely irreversible mutation, but the description says nothing about side effects on the multi-configuration editor, row renumbering after deletion, or error behavior for an invalid row index.

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 short, front-loaded sentence with zero filler. It is efficient, though the extreme brevity is part of why behavioral and usage context is missing.

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

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

For a destructive mutation tool with no annotations and no output schema, the definition is too sparse: it omits what gets deleted, whether the action is reversible, and how failures are surfaced. An agent has only the name and parameter to act on.

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

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

Schema coverage is 100% and the single 'row' parameter is documented as 'One-based row' in the schema, so the description adds no further meaning. Baseline 3 applies when the schema fully documents the 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 a specific verb (Delete) and resource (MCE operand row), which is enough to separate it from the merit-function operand tools like zemax_remove_operand. However, it does not explicitly distinguish itself from the similarly named add/set configuration operand siblings beyond the 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 on when to delete versus modify (zemax_set_configuration_operand_value) or add (zemax_add_configuration_operand), and no note about prerequisites such as needing an active configuration. The agent must infer usage entirely from the 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 provided, the description carries the full behavioral burden. It does flag the operation as 'destructive' and scopes it to disposable systems, which is genuinely useful safety context, but it never states what is destroyed or mutated, whether the change is reversible, or what happens to a real production model.

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 grammatically complete sentence with zero filler and the destructive qualifier front-loaded, which is structurally clean. However, for a seven-parameter irreversible operation, one sentence is under-sized for the task rather than genuinely economical.

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 complex, destructive, seven-parameter mutation with no annotations and no output schema, yet the description omits what the lockdown accomplishes, which settings are affected, and whether results are reversible. An agent would need to infer the entire effect from parameter names alone.

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 100% and every one of the seven parameters carries its own inline description (excludePickups, fixModelGlasses, convertSDToMaxApertures, usePrecisionRounding, decimalPrecision, timeoutSeconds, confirmDestructive). The description adds nothing beyond the schema, so the baseline of 3 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 names a verb and a resource, but 'Design Lockdown' is unexplained jargon — an agent learns nothing about what the operation actually changes (freezing variables, replacing model glasses, converting semi-diameters, rounding values). It adds only the adjectives 'destructive' and a scope qualifier ('owned disposable sequential system'), so it largely restates the title rather than describing the effect.

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 'owned disposable sequential system' is a precondition hint, implying it should be run only on a copy you can discard, but there is no explicit when-to-use guidance and no mention of any alternative or follow-up tool. No sibling is referenced, and the required confirmDestructive gate is never explained in prose.

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, yet it says nothing about whether this is a read-only analysis, what it returns, or any computational constraints. For an analysis tool with no annotations and no output schema, this leaves the agent guessing about the result surface.

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 waste. It is appropriately sized, though it is terse to the point of under-specifying rather than being elegantly concise.

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

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

With no annotations, no output schema, and no parameter guidance in the description, the definition is thin for a ZEMAX analysis tool whose return format (radius vs. energy table) an agent would want to know. The simple two-parameter schema keeps this from being lower, but key context is missing.

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

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

Both parameters have 100% schema description coverage ('Sampling level 1-6', 'Use dashes reference'), so the schema does the explanatory work. The description adds nothing about how sampling affects results, which is the baseline for a fully-covered schema.

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

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

The description states a clear verb ('Calculate') and resource ('FFT diffraction encircled energy versus radius'), which is specific enough to distinguish it from the sibling zemax_geometric_encircled_energy by virtue of the 'FFT diffraction' qualifier. It stops short of explicitly naming that sibling, so it misses the top tier.

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 on when to use this analysis versus the geometric encircled energy sibling or other spot/PSF analyses. The agent must infer the appropriate context from the name alone, which is a significant omission given the large family of analysis tools available.

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. 'Disconnect cleanly' gestures at graceful teardown but does not say whether the application process is terminated, what happens to unsaved work, whether the connection can be re-established via zemax_connect, or what errors are possible.

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, front-loaded with the action and no wasted words. It is efficient, though terse to the point of under-specification rather than genuinely 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?

For a session-terminating tool with zero annotation coverage and no output schema, the definition says nothing about irreversible effects, unsaved-state handling, or the post-disconnect state. An agent cannot tell whether this is a safe, reversible operation.

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

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

Schema description coverage is 100% and the single optional 'save' flag is already documented as 'Save before disconnecting'. The description adds nothing beyond the schema, so baseline 3 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?

States a specific verb (disconnect/close) and resource (owned OpticStudio application), and the word 'owned' hints at a scope distinction versus tools like zemax_close_file. It does not explicitly name a sibling to contrast with, but 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?

No guidance on when to disconnect versus zemax_close_file, zemax_restart, or simply leaving the session open. The only implicit signal is that this ends a session, which the agent must infer from the word 'disconnect'.

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

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

With no annotations present, the description must carry the full behavioral burden. It discloses that the tool is disabled unless explicitly allowed, which is useful, but says nothing about side effects, whether the backend code can mutate state, required permissions, error behavior, or security risk despite being an escape hatch for arbitrary backend expressions.

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 wasted wording, which is structurally concise. However, its brevity comes at the cost of useful detail, so it is efficient but not maximally effective for such an open-ended 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?

Given that this is an advanced escape hatch with no annotations, no output schema, and arbitrary backend-defined input, the description is materially incomplete. It omits return behavior, failure modes, safety considerations, and when the explicit allowance is required, leaving an agent without enough context to invoke it 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?

Schema description coverage is 100%, and the single 'code' parameter is already documented as 'Backend-specific expression or statement.' The description adds no additional meaning about expected syntax, format, or constraints, so the baseline of 3 applies when the schema does the heavy lifting.

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 labels the tool as an 'advanced backend-defined diagnostic/evaluation escape hatch,' which largely restates the tool name/title rather than specifying a concrete verb and resource. It does not clarify what backend-defined evaluation actually does or how it differs from the many specific sibling analysis tools, leaving only a vague sense of 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 states a gating condition ('disabled unless explicitly allowed') but gives no guidance on when to use this tool versus alternatives. There is no indication of which situations call for the escape hatch or which sibling tools should be preferred, so the agent gets availability information but not usage direction.

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

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

No annotations are provided, so the description carries the full burden. It does not explain whether analysis results must already exist, whether the export is idempotent, whether it can overwrite an existing file, or return behavior. It only names the output formats.

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 short sentence with the action front-loaded and the format options included. Nothing extra.

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

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

For a 3-parameter export tool with no annotations and no output schema, the description is minimal. It conveys the basic operation but omits prerequisites (e.g., an analysis must have been run), overwrite behavior, and return handling. Adequate but with clear 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 coverage is 100%, so all three parameters are already documented in the schema, including the format values. The description adds the format list but nothing beyond the schema. Baseline 3 is appropriate.

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

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

Clear verb ('Export') and resource ('an analysis result') with the supported output formats enumerated. It doesn't differentiate from siblings like zemax_save_file, but the verb+resource is specific enough for an agent to understand the 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?

No guidance on when to use this vs alternatives such as zemax_run_analysis or zemax_save_file, or when each format is appropriate. The description states what it does but not when to choose it.

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

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

No annotations are provided, so the description carries the full disclosure burden for a 24-parameter write-to-disk operation, and it says almost nothing. It never mentions overwrite semantics, permission/connection prerequisites, what happens if the directory does not exist, or whether source files are modified; only the outputDirectory schema text hints at a sandboxing constraint.

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 zero filler, and the verb/resource come first. It is arguably under-specified rather than bloated, but as a matter of conciseness there is nothing wasted.

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

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

For a tool with 24 parameters, three required fields, no annotations, and no output schema, one sentence is not enough. The agent gets no picture of the export workflow, the filtering semantics powering the many optional bounds, or the failure modes of writing a catalog file.

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 100%, so all 24 parameters are already documented at the field level; baseline is 3. The description adds no meaning beyond the schema — notably it does not explain how the weighted parameters (wa, wn, wp) interact the numeric filter bounds, which is the one place prose could have helped.

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

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

States a specific verb (Export) and resource (filtered glasses) with a concrete artifact (new AGF catalog). An agent can infer this is the catalog-writing counterpart to the filtering tools. It does not, however, distinguish itself from the nearby zemax_filter_glasses or zemax_get_glass_catalogs, leaving the agent to infer that this is the step that persists filtered results.

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 when-to-use or when-not-to-use guidance, and no alternative is named. The relationship to zemax_filter_glasses (does this tool filter internally, or only export an already-filtered set?) is left entirely to inference, despite the schema containing a full set of filter parameters.

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 says the tool calculates curves but omits whether it is read-only, whether it modifies system state, what the return format is, and any permission or setup requirements. For a computation tool with zero annotation coverage, this is a significant gap.

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

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

A single sentence with no wasted words, and the core action and scope are front-loaded. It is appropriately sized for a straightforward analysis command.

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

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

With no output schema and no annotations, the description should explain what result the agent receives (e.g., MTF values per field, plot, or file). It also lacks any when-to-use context in a crowded MTF sibling group. The description is too sparse to fully guide 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 100%, and each parameter is clearly documented in the schema (sampling level 1-6, frequency max cycles/mm, wavelength 0 for polychromatic). The description adds no extra meaning beyond that, so the baseline of 3 is appropriate.

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

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

States a specific verb ('Calculate') and resource ('diffraction FFT MTF curves') and adds the scope 'for all fields', which distinguishes it from the sibling zemax_fft_mtf_vs_field. However, it does not explicitly name or contrast with other MTF siblings (geometric, huygens), so it stops just short of full differentiation.

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

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

The description gives no guidance on when to use this tool versus the many MTF-related siblings such as zemax_geometric_mtf, zemax_huygens_mtf, or zemax_fft_mtf_vs_field. It does not state prerequisites (e.g., system must be loaded) or exclusions. Usage is only implied by the tool name and purpose.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says nothing about prerequisites (a loaded system, defined fields/wavelengths), whether an analysis window is opened, units, or computational cost. Only the computation itself 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?

A single front-loaded sentence with the verb, resource, scan direction, and limit all present and zero filler. Nothing redundant or buried.

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 7-parameter analysis tool with no output schema, the description covers what is computed but omits prerequisites and any hint about the result. Adequate but leaves the agent to infer the operational context from siblings.

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 100%, so the schema already documents sampling levels and the six frequency slots including the '0 skips' convention. The description adds only that frequencies are capped at six, which is a marginal restatement of the schema. Baseline 3 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?

States a specific verb (Calculate), resource (polychromatic FFT MTF) and a distinct scope (versus Y field, up to six frequencies). This differentiates it from zemax_fft_mtf (MTF vs frequency) and zemax_geometric_mtf_vs_field (geometric rather than FFT), though it never explicitly names those siblings to remove doubt.

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 when-to-use guidance and no alternatives named. An agent facing zemax_fft_mtf, zemax_geometric_mtf_vs_field, and zemax_huygens_mtf gets no help choosing this FFT-vs-field variant over the others.

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 disclosure burden, yet it only restates the computation. It does not say what the analysis returns, whether it requires an open system, or how the four sampling/field settings affect the result.

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 zero waste, which is good structure. However, the extreme brevity leaves the definition under-specified rather than optimally concise for a 4-parameter analysis 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?

With no annotations, no output schema, and four optional parameters, the description should explain return content or setup requirements; it does neither. An agent lacks the context to invoke this analysis 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?

Schema description coverage is 100%, so the four parameters (field, sampling, wavelength, imageSampling) are already documented in the schema, and the description adds nothing further. Baseline 3 is appropriate when the schema does the heavy lifting.

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?

Names a specific verb ('Calculate') and resource ('diffraction FFT point-spread function'), so an agent knows the operation is a PSF computation. It implicitly distinguishes itself from zemax_huygens_psf by the 'FFT' qualifier, but never explicitly states the relationship to that 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 on when to use this tool versus alternatives such as zemax_huygens_psf or zemax_fft_mtf, nor any prerequisites (e.g. a loaded system, defined fields/wavelengths). The agent must infer applicability entirely on its own.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing beyond the computed quantities. It does not state that it operates on the currently loaded system, whether it is read-only, what the return format is, or any limits. For an analysis tool with zero annotation coverage this is a real 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?

A single front-loaded sentence with no wasted words. It is appropriately terse, though the terseness borders on under-specification rather than efficient density.

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 Zemax analysis tool with no annotations and no output schema, an agent needs to know it runs on the loaded system and roughly what comes back; neither is provided. The description names the measured quantities but omits the operational context required to invoke it 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?

Schema description coverage is 100% and there is only one optional parameter, so the schema already documents distortionType ('f_tan_theta or f_theta'). The description adds no meaning beyond this — it doesn't explain what the two distortion conventions mean — so the baseline 3 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?

States a specific verb ('Calculate') and a specific resource ('tangential/sagittal field curvature and distortion'), naming the two quantities produced. It is distinct from siblings like seidel_coefficients and rms_spot, though it does not explicitly contrast itself with them.

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 of when to use this analysis versus alternatives such as zemax_seidel_coefficients or zemax_ray_fan, nor any prerequisite (e.g., that a lens/system must be loaded). The description only says what it computes.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not state the return shape, whether results are ranked by the weighted distance, how defaults (ndTarget 1.5168, vdTarget 64.17, wp 100) affect matching, or whether the operation is purely a read with no side effects.

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

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

A single efficient sentence with the verb front-loaded and no filler. It is arguably too terse for a 21-parameter tool, but nothing in the sentence is wasted.

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

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

For a 21-parameter query tool with no annotations and no output schema, the description leaves the agent without guidance on result ordering, how target/weight parameters combine with distanceRadius, or what comes back. The 100% schema coverage documents individual fields but not how they work together.

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 100%, so every one of the 21 parameters is already documented in the schema and the baseline is 3. The description adds only high-level grouping of those parameters (state, coordinates, cost, TCE, coverage, melt frequency) and no syntax, units, or interaction detail beyond the schema.

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

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

The description gives a specific verb+resource ("Filter glasses") and enumerates the filtering dimensions (preferred state, optical coordinates, cost, TCE, coverage, melt frequency), which maps cleanly onto the schema. It does not name or contrast with the closest sibling, zemax_get_glasses, so an agent must infer the difference between retrieving and filtering.

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 of when to use this tool versus zemax_get_glasses, zemax_get_glass_catalogs, or zemax_export_glass_catalog. The only implied usage is that filtering is appropriate when narrowing a glass list, with no prerequisites such as loading a catalog first.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It does not disclose that the tool mutates the merit function, that clearExisting defaults to true and will delete existing operands, or any other side effects.

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

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

A single sentence with no filler, front-loading the core action. It could be slightly expanded for a ten-parameter tool, but it is not verbose.

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

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

Given ten optional parameters, no annotations, and no output schema, the description is too thin. It omits that the operation modifies the merit function, the destructive default of clearExisting, and any guidance on sampling choices.

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 100%, so the schema already documents all ten parameters with defaults and meanings. The description adds no parameter-level information beyond what the schema provides.

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

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

States a specific verb and resource: 'Build explicit OPD operands using Forbes 1988 Gaussian quadrature sampling.' This distinguishes it as a merit-function operand generator, but it does not name or differentiate from siblings like zemax_merit_wizard or zemax_add_operand.

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 no guidance on when to use this tool versus alternatives such as zemax_merit_wizard, zemax_optimization_wizard, or manually adding operands. No exclusions or context 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 provided, so the description carries the full disclosure burden. It states the calculation is ray-based, but says nothing about prerequisites (e.g. whether a system must be loaded/connected), whether results are written to the lens file, or what the analysis returns. For a bare analysis tool this leaves real behavioral gaps.

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

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

A single compact sentence with the resource and output axis front-loaded and zero filler. It is efficient, though the terseness is partly under-specification rather than disciplined concision.

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 five optional parameters, no annotations, and no output schema, the description should explain what the analysis returns and when it applies. It provides only the one-line purpose, leaving the agent without return-value or usage context for a moderately parameterized analysis 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 100%, so all five parameters (sampling, useDashes, scatterRays, showDiffractionLimit, scaleByDiffractionLimit) are already documented in the schema. The description adds no parameter-level meaning, so the baseline of 3 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 gives a specific verb and resource: 'Calculate ray-based geometric encircled energy versus radius.' That is enough to know exactly what the tool produces. However, it never distinguishes itself from the sibling 'zemax_diffraction_encircled_energy', which an agent could easily confuse it with.

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 qualifier 'ray-based geometric' implicitly signals the ray-trace regime as opposed to a diffraction computation, which is a usable hint. But there is no explicit when-to-use, when-not-to-use, or named alternative despite the diffraction encircled-energy sibling existing.

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

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

With no annotations, the description carries full behavioral burden. It hints at a return/export of an 'image grid' but does not disclose whether it requires an open system/file, what the grid represents, whether export is conditional on filePath, or any side effects.

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

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

A single compact sentence that is front-loaded with the action. It is efficient but arguably too terse to earn a top score given the tool's complexity.

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

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

For a 5-parameter analysis tool with no annotations and no output schema, the description omits prerequisites, the meaning of the returned grid, and export behavior. The agent is left to guess about invocation 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 100%, so each of the 5 parameters (field, showAs, filePath, raysX1000, wavelength) is documented in the schema itself. The description adds nothing beyond the 'image grid' notion, so the baseline 3 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?

States a specific verb+resource ('Run geometric image analysis') and adds the output intent ('return/export the image grid'). It is clear on its own, but it does not distinguish itself from siblings like zemax_geometric_encircled_energy, zemax_geometric_mtf, or zemax_geometric_mtf_vs_field.

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 indication of when to use this vs. other geometric analyses or when export is appropriate. The only hint is the 'filePath' parameter and the word 'export', leaving selection entirely 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?

No annotations are provided, so the description carries the full burden, and it discloses almost nothing: 'Calculate' implies a non-destructive read/compute, but there is no mention of prerequisites (open file, connection state), whether results are cached or recomputed, or what the analysis returns. For an analysis tool with zero annotation coverage this is a significant gap.

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

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

It is a single, front-loaded sentence with no filler or redundancy. The brevity is efficient, though it borders on under-specification rather than true conciseness.

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

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

There is no output schema and no annotations, so the description should compensate by describing the return shape (MTF curves across frequency for each field) and any prerequisites. For a 3-parameter analysis tool it leaves the agent without enough context to invoke it 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?

Schema description coverage is 100% – wavelength ('0 for polychromatic'), maxFrequency ('Maximum cycles/mm'), and multiplyByDiffractionLimit are all documented in the schema. The description adds no additional semantics beyond that, so the baseline of 3 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 and resource ('Calculate geometric MTF curves') plus scope ('for all fields'), which is clear enough to identify the operation. However, it does not differentiate itself from closely related siblings such as zemax_fft_mtf, zemax_huygens_mtf, or zemax_geometric_mtf_vs_field, which an agent would need in order to choose correctly.

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 of when to use this tool versus the FFT MTF, Huygens MTF, or MTF-vs-field variants, and no prerequisites (e.g., a loaded lens system and a connected session are implied but not stated). The agent is left to infer the selection criteria 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, the description carries the full behavioral burden and falls short. It does not state that this is a non-mutating analysis, whether it requires existing field definitions, what happens when all six frequencies are left at 0, or how results are presented.

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. It is efficient, though the brevity is part of the under-specification problem rather than a virtue in itself.

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 an analysis tool with no output schema and no annotations, the description should say what the result contains and what system state it depends on. It says neither, leaving an agent unable to predict the return value or prerequisites.

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 100% and every parameter documents its own '0 skips' behavior, so the baseline is 3. The description only adds the count ceiling ('up to six frequencies'), which is already evident from the six properties, so it contributes nothing beyond the schema.

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

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

States a specific verb and resource: calculate geometric MTF versus field. This distinguishes it from zemax_geometric_mtf (presumably vs frequency) by the 'versus field' scope, but it never names or contrasts the nearest sibling, zemax_fft_mtf_vs_field, so an agent must infer the geometric-vs-FFT distinction.

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

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

No guidance on when to choose this over zemax_fft_mtf_vs_field, zemax_geometric_mtf, or zemax_huygens_mtf. No prerequisites (fields/wavelengths must be defined first), no statement that it is an analysis-only read operation.

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 burden. It does not disclose that this is a read-only operation, whether it requires an active connection, what it returns, or any side effects. Only the word 'Get' hints at read-only 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?

A single, compact sentence that is front-loaded and wastes no words. Appropriate for a simple getter.

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

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

Given the tool's simplicity (0 params, no output schema), the description is adequate but incomplete. It should mention that this reads the sequential mode's afocal setting and possibly what the return value represents (true/false or mode type). Missing connection requirements.

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

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

There are zero parameters, so the baseline is 4. The description correctly indicates no inputs are needed, and the empty schema confirms this. No parameter semantics to add.

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

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

States a specific verb (get) and resource (sequential afocal-mode setting), which is clear enough for an agent to act on. However, it does not distinguish itself from the sibling set_afocal_mode beyond naming, and it doesn't clarify scope or context. Read-only nature is implied but not explicit.

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

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

No guidance on when to use this tool versus alternatives, no prerequisites, and no mention of related tools like zemax_set_afocal_mode or zemax_get_system. The agent must 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 provided, so the description carries the full disclosure burden, and it discloses nothing about behavior. It doesn't confirm this is a non-mutating read, whether a system must be open/connected first, or what the returned settings contain.

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 short sentence with no padding, which is appropriate for a zero-argument getter. It is terse to the point of under-specification rather than wasteful, so it stays in the upper-middle range.

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

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

With no output schema and no annotations, the description is the only source of information, and it says nothing about what apodization types exist, what fields come back, or any prerequisites. For a getter returning domain-specific optical data, this is insufficient.

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

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

The tool takes zero parameters, so the baseline is 4; there is nothing for the description to clarify beyond what the empty schema already conveys.

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

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

States a specific verb ('Get') and resource ('aperture apodization settings'), which is clearly distinct from the sibling zemax_set_apodization. However, it offers no further differentiation or scope detail beyond the name itself.

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

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

No guidance on when to use this rather than zemax_get_aperture, zemax_get_system, or zemax_set_apodization. The read/write pairing with zemax_set_apodization is inferable from naming alone, not 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 provided, so the description carries the full burden, and it only names the returned fields. It says nothing about whether the surface must be of Even Asphere type, what happens on a non-aspheric surface, permission/connection requirements, or error behavior. For a read-only getter the risk is low, but the disclosure is thin.

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 compact sentence that front-loads the key information with no filler. However it is arguably under-specified rather than concise: the brevity comes at the cost of any usage or behavioral 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?

For a one-parameter getter with no output schema, the description at least enumerates what is returned (conic and alpha1-alpha8), which compensates somewhat for the missing output schema. It still omits the precondition that the surface be an even asphere and any error/edge-case behavior, leaving meaningful gaps for its complexity level.

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 100% but the schema text is only 'Surface number', adding little. The description adds no format, indexing convention (e.g. surface 0 = object), or valid-range information beyond the parameter name. Baseline 3 is appropriate where the schema carries the parameter.

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

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

States a specific verb (Get) and resource (Even Asphere surface) plus the exact returned quantities (conic, alpha1-alpha8), so an agent knows it reads aspheric coefficients rather than general surface data. It doesn't explicitly distinguish itself from the many sibling getters (e.g. zemax_get_surface, zemax_get_extra_data) or note the inverse sibling zemax_set_aspheric_surface, but the resource is specific enough to disambiguate.

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 when-to-use guidance at all: no mention that the surface must be an even-asphere type, no prerequisites, no statement of when to prefer this over zemax_get_surface or zemax_get_extra_data. The agent must 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 provided and the description adds no behavioral context such as read-only status, required system state, or that it returns a margin value. It is a pure restatement with no disclosure beyond the name.

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 single sentence is concise but purely tautological, adding no information beyond the title. Conciseness here reflects under-specification rather than efficient communication.

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 getter, the description should at least state what value is returned and its context in an optical design workflow. Without annotations or an output schema, the description carries full burden and fails to provide meaningful 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?

The tool takes zero parameters, so the baseline is 4. Schema coverage is 100%, and there are no parameters whose semantics need 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 restates the tool name almost verbatim ('Get the clear semi-diameter margin'), providing a verb and resource but no additional clarifying detail. It conveys the basic purpose but does not explain what the margin is or how it differs from sibling tools like zemax_get_surface or zemax_get_system.

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 on when to use this tool versus alternatives. An agent cannot infer from the description whether this is a diagnostic check, a setup query, or a value needed before calling zemax_set_clear_semi_diameter_margin.

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 but provides minimal behavioral context. It does not disclose whether this requires an active connection, whether it mutates state, or what the return format looks like. It simply states a read 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, efficient sentence that front-loads the core action and scope. It is appropriately sized and contains no extraneous information.

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

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

Given the simplicity (no parameters, no annotations, no output schema), the description is minimal but arguably sufficient for a basic getter. However, without any behavioral context or usage guidance, an agent might not know when this tool is appropriate or what to expect, leaving some 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?

There are zero parameters, which is appropriate for a getter that retrieves configuration info. The description does not need to explain parameters, so this is fine. Baseline for zero params is 4.

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

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

The description clearly states the specific verb 'Get' and the specific resource 'configuration', with the scope 'number of configurations and current configuration'. This is precise and distinguishes it from siblings like zemax_set_current_configuration or zemax_get_configuration_operands by focusing on the count and current index.

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 explicit guidance on when to use this tool versus alternatives. The description does not mention prerequisites or related tools (e.g., use before setting configurations).

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. 'Get' implies a read, but nothing is said about whether a file must be open, how these differ from a configuration summary, or how large result sets are bounded. The endRow=0 convention is left to 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?

A single sentence with no filler, front-loaded with the action and resource. Nothing wasted, nothing buried.

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

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

For a two-parameter read tool with no output schema and no annotations, the description conveys the gist but omits what the returned operand/value structure looks like and whether results are paginated by row. Adequate but not fully self-sufficient.

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

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

Schema description coverage is 100%, so startRow/endRow semantics are fully documented in the schema and the baseline is 3. The description adds only the phrase 'across configurations', which reinforces scope but adds no row-range or format detail beyond structured data.

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

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

States a specific verb (Get) and resource (MCE operands and values across configurations), which is clear enough for an agent to know this is a read of multi-configuration editor data. It does not distinguish itself from close siblings like zemax_mce_summary or zemax_get_configuration, so it falls short of 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 when-to-use guidance, no mention of prerequisites (e.g. an open file with configurations defined), and no routing to alternatives such as zemax_mce_summary or zemax_get_configuration. The agent must infer usage entirely from the 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?

No annotations are provided, so the description carries the full behavioral burden. 'Read' implies a non-mutating operation, which is useful, but nothing is said about return format, whether XDAT exists on all surfaces, or what happens when parameters are out of range.

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 zero waste. It is terse but efficient rather than padded.

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

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

With no annotations, no output schema, and three parameters, the description is too thin to fully position the tool. It does not say what the returned XDAT values look like or how they relate to surface definitions.

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 100%, with startParameter, endParameter, and surfaceNumber all documented (including the '0 means all' default behavior), so the schema does the heavy lifting. The description adds no parameter detail beyond naming the concept.

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

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

States a specific verb (Read) and resource (surface Extra Data / XDAT values), so an agent can distinguish it from the sibling set_extra_data. It lacks explicit differentiation from other getter tools such as get_surface, but the purpose itself 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?

No guidance on when to use this tool versus sibling getters (get_surface, get_surface_solves) or when to prefer set_extra_data. The agent must infer context 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 provided, so the description carries the disclosure burden. 'List' is a reasonably strong read-only, side-effect-free signal, which is the main behavioral trait that matters for a catalog enumeration. It says nothing about ordering, scope, or whether the returned list depends on session/license state.

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 short sentence that front-loads the verb and the resource with no filler. Nothing could be trimmed without losing meaning.

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-param enumeration tool with no output schema and no annotations, the description conveys the essentials (what is listed, from where). It falls short of fully positioning the tool among the several other glass-catalog siblings, which is the main remaining ambiguity.

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 there is no parameter semantics to convey; the baseline for a parameterless tool is 4.

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

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

States a specific verb ('List') and resource ('glass catalog names installed in Glasscat'), so an agent knows exactly what comes back. It does not, however, distinguish this from near-siblings like zemax_get_glasses, zemax_filter_glasses, or zemax_export_glass_catalog, so sibling differentiation is missing.

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 of when to use this tool versus the adjacent glass-related tools (get_glasses, filter_glasses, export_glass_catalog). The agent must infer usage purely from the name and the word '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?

No annotations are provided, so the description must carry the behavioral disclosure burden. 'List' strongly implies a read-only operation with no side effects, which is useful, but the description does not explicitly state read-only behavior, output shape, pagination, or failure conditions.

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 states the resource, the returned properties, and the source in the fewest words necessary.

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

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

For a simple one-parameter listing tool with full schema coverage, the description is mostly complete: it identifies the resource, source, and type of properties returned. It could optionally mention output format or whether all catalog glasses are returned, but nothing critical is missing.

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

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

Schema description coverage is 100%, so the parameter documentation already explains that 'catalogs' is a comma-separated list of catalog names. The description adds 'from catalogs' but does not extend parameter meaning beyond the schema, so the baseline score of 3 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 verb and resource: list glasses and their optical/manufacturing properties from catalogs. It does not explicitly distinguish itself from close siblings such as zemax_filter_glasses or zemax_get_glass_catalogs, but the core purpose is unambiguous.

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

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

The description says what the tool does but gives no guidance on when to use it versus alternatives like zemax_filter_glasses or zemax_get_glass_catalogs. No prerequisites, exclusions, or selection criteria are provided.

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 disclosure burden. Beyond the word 'Retrieve' implying a read, it says nothing about cost of value calculation, whether rows are paginated like startRow/endRow suggest, or what error/lack-of-merit-function behavior looks like.

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; the resource and the value-retrieval option come first. It is efficient, though the same brevity is what leaves the guidance gaps.

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

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

With no annotations, no output schema, and no sibling differentiation, a three-parameter query tool needs more than one sentence. Return shape, row-range semantics, and how it differs from zemax_merit_value are all unaddressed.

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 100%, so startRow, endRow, and includeValues are already documented in the schema and the baseline is 3. The phrase 'optional calculated values' loosely echoes includeValues but adds no format, range, or cost detail beyond the schema.

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

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

States a specific verb and resource: retrieve merit-function operands (and their calculated values). That tells an agent exactly what the tool returns, but it does nothing to separate it from close siblings such as zemax_merit_value, zemax_merit_wizard, or zemax_forbes_merit_function.

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 guidance, no condition selecting it over zemax_merit_value or zemax_load_merit_function_file, and no stated prerequisites. The agent is left to infer context 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 provided, so the description carries the full burden, and it discloses only that a value is fetched. It does not say whether this reads a lens/system setting, what the returned unit identifier looks like (e.g. cycles/mm vs cycles/mrad), or whether any session state is required.

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. Nothing could be removed without losing the tool's identity.

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 trivial no-argument getter this is nearly adequate, but with no output schema the description never states what form the returned unit takes, which is the one piece of information a caller of a 'get units' tool actually needs.

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 there is nothing for the description to disambiguate; the baseline for a parameterless tool 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?

States a specific verb ('Get') and resource ('MTF spatial-frequency units'), which is enough to separate it from the sibling setter zemax_set_mtf_units. It is slightly cryptic about what 'MTF units' concretely means (the unit convention used for MTF spatial frequency), but the read direction and target setting are 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?

No guidance on when to call this versus alternatives, and no mention of the paired setter zemax_set_mtf_units or of the MTF analysis tools whose output this setting governs. Usage must be inferred entirely from the 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?

No annotations are provided, so the description must carry the behavioral disclosure burden. It implies a read-only operation but does not state whether it requires an open system, is idempotent, or what it returns. It is minimal.

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 extraneous words. Appropriately concise for a no-parameter getter.

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 getter with no output schema, the description should ideally describe what 'polarization settings' includes (e.g., mode, parameters) to help an agent interpret the return. It is adequate but leaves gaps in return value expectations.

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?

Zero parameters, so the schema is trivially complete. The description adds no parameter information because there are none, which meets the baseline of 4 for 0-param tools.

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

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

States a specific verb 'Get' and resource 'polarization settings', clearly indicating a read operation. However, it does not differentiate from sibling zemax_set_polarization or mention what makes this distinct beyond the 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 on when to use this tool versus alternatives like zemax_set_polarization or other getters. The description simply states its function without context or conditions.

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

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

With no annotations, the description carries the full behavioral burden and discloses almost nothing: it does not confirm the operation is a safe read, list affected settings, or describe the returned state. A single clause restating the name leaves most behavioral questions unanswered.

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 short sentence with no padding, appropriately sized for a trivial zero-argument getter. It is front-loaded, though extremely terse.

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?

No output schema exists, so the description should explain what the ray-aiming setting returns or what form it takes; it does not. For a getter with no annotations and no return documentation, the definition is incomplete for correct downstream use.

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 per the rubric a baseline of 4 applies; there is nothing for the description to disambiguate. Schema coverage is 100% and no enums or nested objects exist.

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

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

States a specific verb ('Get') and resource ('ray-aiming setting'), which clearly distinguishes it from the sibling setter zemax_set_ray_aiming. It is clear but does not explicitly differentiate itself from adjacent getters, 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 description offers no when-to-use context, no prerequisites, and no alternatives. The read-only intent is only inferable from the 'Get' verb, so an agent gets implied but unstated 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?

No annotations are supplied, so the description carries the full behavioral burden. It does not state that this is a read-only operation, what happens with out-of-range surface numbers, or whether it requires an open sequential file, leaving the safety and prerequisite profile undocumented.

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 short, front-loaded sentence with no wasted words. Its brevity is efficient, though it edges toward under-specification rather than rich conciseness.

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

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

For a read tool with no annotations and no output schema, the description leaves the return shape and read-only nature entirely undocumented. In a namespace this large, that is an inadequate level of 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 coverage is 100%; the single parameter already documents the 0=object / -1=image convention. The description adds no indexing or format detail beyond what the schema provides, so the baseline 3 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?

States a specific verb (get) and resource (surface) with the qualifier 'sequential', distinguishing it from the many nsc_* siblings. It does not name a specific alternative reader like zemax_nsc_get_object or zemax_get_surface_solves.

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 when-to-use, when-not-to-use, or alternative routing is given. In a ~130-tool namespace with multiple surface-access tools (zemax_get_surface_solves, zemax_get_aspheric_surface, zemax_nsc_get_object), the agent gets no help choosing this one.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Get' implies a read-only operation, but the description does not disclose return format, error conditions, whether the surface must exist, or any other behavioral trait beyond the basic retrieval intent.

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 wasted words. It is appropriately sized for a simple getter 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?

There is no output schema and no annotations, so the description should ideally say more about what is returned or how the surface solve states are structured. The input is fully covered by the schema, but the lack of return-shape information leaves a noticeable gap.

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

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

Schema description coverage is 100%, so the schema already documents the single parameter ('surfaceNumber': 'Surface number'). The description adds no parameter meaning beyond that baseline, which is acceptable when the schema fully covers the 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 a specific verb ('Get') and resource ('solve, pickup, and variable states for all surface properties'), so the agent knows this is a retrieval tool for surface solve data. It does not explicitly distinguish itself from sibling tools like zemax_get_surface or zemax_get_variables, but the resource is concrete enough to be understood.

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 when-to-use guidance is provided. The description does not say when to choose this tool over zemax_get_surface, zemax_get_variables, or other related getters, nor does it state any 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?

No annotations are provided, so the description carries the full disclosure burden. 'Get' implies a read, but the description never states that it is non-mutating, whether it requires a connected/live Zemax session, how large the payload may be, or what happens when all includes are disabled.

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, and the optional components are listed in the same order as the parameters. It is efficient, though the brevity borders on under-specification for a general-purpose reader.

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

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

With no output schema and no annotations, the description should say more about the shape and scope of the returned 'system data' and its relationship to narrower getters. As written it is minimally viable for a zero-required-parameter getter but leaves the agent guessing about the return payload.

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 100%, so all three booleans are already documented with their meanings and defaults in the schema. The description merely restates that surfaces, fields, and wavelengths are optional, adding no format or interaction detail beyond the structured fields.

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

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

States a specific verb ('Get') and resource ('optical-system data') and enumerates the three optional sub-resources. It does not, however, differentiate itself from the many sibling readers such as zemax_get_configuration, zemax_get_title_notes, or zemax_lde_summary, so an agent cannot tell from this text alone which getter to pick.

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 'optionally' hints that the includes are toggles, but there is no when-to-use guidance, no statement that this is the general system-level reader versus the granular siblings, and no 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing beyond the name. It does not say whether the call is a pure read, what happens if no system is open, or what unit values can come back — the 'current' qualifier is the only added context.

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

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

One short, front-loaded sentence with no filler or repetition. It is efficient, though the extreme brevity is part of why behavioral detail is absent rather than a virtue of tight writing.

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 getter this is close to adequate, but with no output schema the description should indicate what is returned (unit options such as mm/inches) or any precondition such as an open system file. As written, the agent must discover the return semantics by calling 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?

The tool takes zero parameters, so per the rubric the baseline is 4. The description correctly implies a no-argument getter scoped to the active system, and there is nothing parameter-related to compensate for.

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

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

States a specific verb ('Get') and resource ('the current optical system's lens units'), so the agent knows exactly what is retrieved. It is distinguishable from zemax_set_system_units by the verb, but it does not explicitly name or contrast with that sibling or with zemax_get_mtf_units.

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 only implied: read the lens units of the currently open system. There is no statement of when to prefer this over zemax_get_mtf_units or any prerequisite (e.g., a file must be loaded), leaving the agent to infer 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 full burden. It conveys that this reads the 'current' system, implying an active file or connection context, but does not explicitly state read-only safety, side effects, or error 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?

A single, front-loaded sentence with zero waste. Every word contributes to identifying the resource being retrieved.

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?

Lists the fields returned (title, notes, author), which compensates for the missing output schema. For a zero-parameter getter it is adequate, though it could mention the need for an open system.

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

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

The tool has zero parameters, so the baseline is 4. There is no parameter semantics for the description to clarify, and the empty schema is 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?

States a specific verb ('Get') and resource ('current optical system's title, notes, and author'). It distinguishes itself from the sibling zemax_set_title_notes by being a read operation, though it does not explicitly contrast with broader getters like zemax_get_system.

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 when-to-use guidance, prerequisites, or alternatives are provided. An agent must infer that this is for reading metadata when an optical system is active.

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. 'Scan' implies a read operation, but nothing states whether it is read-only, what a partial or empty result means, or what the returned variable/constraint state looks like. For a getter with zero structured support, this is a notable 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?

A single tight sentence with the resource front-loaded and no filler. It is efficient, though quite sparse given the absence of any other structured documentation.

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

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

With no output schema, no annotations, and no parameters, the description is the only documentation an agent has. It identifies the subject matter ('variables and constraint states') but says nothing about return shape, so it is only minimally complete.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing parameter-related for the description to compensate for.

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

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

States a clear verb ('scan/get') and resource ('optimization variables and constraint states'), which is specific enough to distinguish it from the write-side siblings zemax_set_variable and zemax_set_variable_constraints. It stops short of naming those siblings explicitly, so it earns a 4 rather than 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 when-to-use guidance, no prerequisites, and no mention of alternatives such as zemax_get_merit_function or zemax_set_variable_constraints. The context is only loosely implied by the word 'optimization'.

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

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

With no annotations, the description carries the full behavioral burden and falls short. It does not disclose what the operation mutates (variables, glasses), whether it modifies the open file irreversibly, expected runtime, or that it may run long given a timeout parameter. 'Optional glass substitution' is asserted with no explanation of its effect.

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; the core action leads. It is efficient, though arguably too terse given the absence of annotations and output schema.

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

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

For a mutation/optimization tool with no annotations and no output schema, the description is too thin. It omits whether the current system is modified, what becomes of results, and how this relates to the many sibling optimizers, leaving the agent under-informed.

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

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

Schema coverage is 100%, so the four parameters (cores, algorithm, timeoutSeconds, solutionsToSave) are fully documented in the schema, establishing a baseline of 3. The description adds nothing about parameters, and oddly references glass substitution, which has no corresponding parameter.

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

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

The description states a specific verb and resource: 'Run native global optimization.' However, it does not differentiate this from siblings that also perform global optimization, notably zemax_hammer (a global method) and zemax_multistart_optimize, so an agent cannot confidently choose between them from the text alone.

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 on when to use this versus zemax_optimize, zemax_hammer, zemax_multistart_optimize, or zemax_constrained_optimize. The mention of 'optional glass substitution' is not framed as a condition or prerequisite for invoking the tool.

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

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

No annotations are provided, so the description carries the full burden. 'Run native Hammer optimization' implies a computation that likely mutates the optical system, but it does not state that it modifies the system, whether a merit function is required, how long it may run, or what 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 a single front-loaded sentence with no filler. It is concise, though its extreme brevity means it omits almost all useful context rather than being padded.

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

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

For an optimization tool with no annotations and no output schema, the description is far too thin. It omits prerequisites, whether other optimization tools should be preferred, expected behavior, and any relation to the many sibling optimization and analysis tools.

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 100%, so all five parameters are already documented in the schema. The description adds no additional parameter semantics, so the baseline of 3 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?

States a specific verb, 'Run', and a specific resource, 'native Hammer optimization'. This distinguishes it from generic optimization siblings like zemax_optimize and zemax_multistart_optimize, but it does not explicitly say what Hammer is or how it differs from those 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?

Provides no when-to-use guidance, no prerequisites, and no comparison to alternative optimization tools such as zemax_optimize, zemax_global_search, or zemax_multistart_optimize. The agent must infer usage entirely from the 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?

No annotations are provided, so the description carries the full behavioral burden. It doesn't state whether the system must be connected, whether the calculation is computationally expensive, what the output looks like (no output schema), or whether prior analysis settings apply. For a heavyweight optical analysis with zero annotation coverage, this is 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?

A single efficient sentence with no waste. Slightly under-specified for the tool's complexity, but the structure is front-loaded and clear.

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

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

With no annotations, no output schema, and nine parameters, the description is far too thin. It doesn't explain the return values, the computational cost, prerequisites (e.g., a loaded system, valid fields/wavelengths), or how it differs from the multiple other MTF tools in the sibling list.

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 100%, so the schema already documents all nine parameters with defaults and semantics. The description adds no parameter-level detail beyond 'direct pupil integration'. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb+resource ('Calculate Huygens MTF') and the method ('direct pupil integration'), which distinguishes it from siblings like zemax_fft_mtf or zemax_geometric_mtf. However, it doesn't explicitly name those alternatives, so the agent must infer the distinction from domain knowledge rather than the description.

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

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

No guidance on when to use this tool versus zemax_fft_mtf, zemax_geometric_mtf, or zemax_huygens_psf. An agent must know optics to choose correctly; the description provides no conditions, prerequisites, or alternatives.

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

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

Annotations are absent, so the description carries the full behavioral burden, and it delivers almost nothing. It does not state that this is a read-only analysis, whether it requires an open system file, computational cost, or how the result is returned. 'Calculate' implies a non-mutating computation but this is inferred, not stated.

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

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

A single short sentence with no waste and the core action front-loaded. It is efficient, though it is arguably too terse given the tool's complexity.

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

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

For a four-parameter optical analysis tool with no annotations and no output schema, the description is insufficient. It communicates neither operational prerequisites (such as requiring an open lens file), nor how this PSF differs from the FFT PSF variant, nor the shape of the returned data.

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 100%: field is documented as one-based, wavelength as 0-for-polychromatic, and both sampling parameters are named. The description adds no parameter meaning beyond the schema, which is acceptable given the high coverage baseline of 3.

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

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

States a specific verb ('Calculate') and resource ('Huygens point-spread function'), which identifies the operation. However, it does nothing to distinguish itself from closely related siblings like zemax_fft_psf or zemax_huygens_mtf, so an agent cannot tell from the description alone when this PSF variant is appropriate.

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 contains no when-to-use guidance, no alternatives, and no exclusions. With siblings such as zemax_fft_psf and zemax_huygens_mtf, the omission leaves the agent with no basis for selection.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Report' implies a safe read, but it does not disclose what information is returned, whether it requires an open session, or how results are structured — a notable gap given there is no output 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?

A single short sentence with no filler and the action front-loaded. It is efficient, though its brevity is partly because it omits needed detail rather than because it is optimally tight.

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

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

With no output schema and no annotations, the description is the only source of information about what this tool returns, and it says only 'session and optical-system information.' An agent cannot tell what a caller will actually receive or how it differs from zemax_status.

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 there is nothing for the description to clarify beyond what the empty schema already communicates. 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 verb 'Report' and the object 'session and optical-system information' give a rough sense of the tool, but the scope is vague and heavily overlaps with siblings like zemax_status, zemax_get_system, and zemax_get_title_notes. Nothing in the description lets an agent distinguish it from those 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?

There is no indication of when to call this versus zemax_status or zemax_get_system, nor any prerequisites such as needing an active connection. The agent must infer usage 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?

No annotations are provided, so the description carries the full behavioral burden. "Calculate" implies a read-only operation, but there is no disclosure of return format, permissions, or any other behavioral trait. For a computation tool with no annotations or output schema, this is sparse.

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 efficient sentence with no filler, and the operation is front-loaded. It is sized appropriately for a zero-parameter tool, though the extreme brevity borders on under-specification rather than elegant conciseness.

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

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

For a zero-parameter analysis tool, the description minimally explains what is computed and that no inputs are required. However, it omits return-value context despite the absence of an output schema, and it does not help an agent choose this tool over similar Zemax analysis siblings.

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

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

The tool has zero parameters, so there are no parameter semantics to document. The empty schema is complete for a no-input operation, and the baseline score for 0 parameters 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 and resource: "Calculate lateral color versus field." It is not a tautology and clearly identifies the computed aberration. However, it does not differentiate the tool from related sibling analysis tools such as zemax_longitudinal_aberration or zemax_chromatic_focal_shift.

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

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

The description gives no guidance on when to use this tool instead of alternatives. It does not mention prerequisites, when-not conditions, or related Zemax analyses. It merely states what the tool calculates.

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 never states that inserting a surface shifts the indices of all subsequent surfaces, whether an out-of-range position errors or clamps, whether the operation is undoable, or what the call returns.

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 short sentence with no filler, and the key constraint (zero-based) is front-loaded. It is efficient, though its brevity is partly under-specification rather than disciplined conciseness.

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

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

The single parameter is fully documented and no output schema is expected, so the basic contract is covered. For a mutation tool with zero annotations in a complex optical-design domain, though, the side effects on surface numbering and error behavior are missing.

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

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

Schema description coverage is 100% and the single parameter is documented as 'Zero-based insertion position', which the description essentially restates as 'zero-based LDE position'. Baseline 3 is correct since the schema does the work and the description adds no new meaning (e.g., valid range or end-of-list 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?

States a specific verb ('Insert') and resource ('surface') plus the positional semantics ('zero-based LDE position'), so an agent knows this mutates the lens data editor. However, it does not differentiate itself from close siblings like zemax_add_surface or zemax_lde_set_surface, leaving the agent to guess which mutation primitive applies.

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 when-to-use guidance, no prerequisites, and no mention of alternatives. With zemax_add_surface, zemax_lde_set_surface, and zemax_remove_surface all present, the choice between 'insert', 'add', and 'set' is left entirely 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?

No annotations are provided, so the description carries the full burden. It says 'editing' but doesn't state whether changes are reversible, what happens to unspecified properties, whether the surface must exist, or what permissions are required. 'Legacy wrapper' hints at deprecation but gives no concrete behavioral detail.

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, short sentence with no filler. It is front-loaded but underspecified rather than concise-and-complete; still, nothing is wasted.

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

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

For a 6-parameter mutation tool with no annotations and no output schema, the description is inadequate. It omits return behavior, error conditions, and the relationship to the non-legacy surface setters, leaving the agent to guess how to call it correctly.

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