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

With no annotations provided, the description carries full responsibility and does an excellent job. It explains that success only means the code ran, that the Verification line is the verdict, details the verification payload structure, warnings, certificate semantics, and how to get certificates. It even clarifies that a certificate alone is not a solver verdict, making behavior highly transparent.

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

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

The description is thorough but lengthy, spanning multiple paragraphs with extensive detail about verification payloads and edge cases. While well-structured and logically ordered, it is not concise; many sentences could be condensed without losing essential guidance, though the complexity of the tool may justify some verbosity.

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

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

Given the tool's complexity, a simple one-parameter schema, no annotations, and no output schema, the description is exceptionally complete. It covers execution requirements, output interpretation (success vs verification), the structure of the verification payload, warnings, certificates, and how to obtain them. Nothing an agent needs to correctly use the tool is missing.

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

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

The schema already documents the single 'code' parameter with 100% coverage, including the requirement to call export(). The description adds context about typical usage (with generate_code) and output interpretation, but does not meaningfully enhance the parameter semantics 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?

The description clearly states the action ('Execute Python code') and the specific resource (sandboxed environment with numpy, math, and ax_core.argmin). It distinguishes itself from other execute_code siblings by naming the argmin library and mentions its typical pairing with generate_code, making the tool's purpose 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 notes it is typically used to run code from the generate_code tool but also accepts hand-written code, which gives clear context for when to use it. It doesn't explicitly exclude other execute_code tools, but the library-specific scope strongly implies it's for argmin-related code, so the guidance is clear enough.

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

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

No annotations provided, so description fully owns transparency. It discloses that the tool returns executable code and an explanation, and notes that execution is separate. Could mention no side effects or permissions 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?

Two sentences that are front-loaded and to the point. Every sentence provides value with no redundancy.

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

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

Given the tool's complexity (code generation for multiple problem types) and lack of output schema, the description covers key points: purpose, return value, and relationship to sibling. Could elaborate on input format for problem_description, but schema handles that.

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 baseline 3. The description adds no additional parameter-level details beyond what the schema already 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?

Clearly states it generates Python code for numerical problems using the argmin library, lists supported problem types explicitly, and distinguishes from sibling tools like execute_code.

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

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

Explicitly mentions that code must be executed separately using execute_code. Implicitly distinguishes from other code generators via argmin focus, but could add more explicit when-not-to-use pointers.

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

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

No annotations are provided, so the description bears the full burden. It lists the required and optional parameters but does not disclose potential side effects (e.g., whether feedback is stored or affects future behavior). The description is straightforward but lacks deeper behavioral context.

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

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

The description is extremely concise: one sentence stating the purpose, followed by a bullet list of parameters. Every sentence is necessary and adds value, with no wasted words.

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

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

Given the tool's simplicity (a reporting meta-tool), the description covers all necessary information: what it does, when to use it, what parameters to include, and how to provide feedback. It is complete without needing an output schema.

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

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

Schema coverage is 100%, and the description adds value by listing each parameter with an explanation (e.g., 'previous_called_tool_name: the name of the previous tool called'). It also clarifies defaults for feedback_value and the optional nature of feedback, enhancing understanding 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 clearly states 'Summarize the tool call you just executed. Always call this after using any other tool.' It specifies the verb 'summarize' and the resource 'tool call', differentiating it from sibling tools that perform distinct tasks such as fitting models or parsing documents.

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

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

The description provides explicit guidance: 'Always call this after using any other tool.' This makes the usage context clear. It does not mention when not to use it or suggest alternatives, but given the nature of a feedback reporting tool, the guidance is sufficient.

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

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

With no annotations, the description should disclose behavioral traits. It mentions file type support but does not indicate whether the operation is read-only, destructive, or what the output includes. Lacks details on side effects or authentication needs.

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

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

The description is very short and front-loaded. Every sentence adds value (purpose + supported types). No wasted words, but could be more informative in the same space.

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 lack of output schema, the description should explain what the annotation result is. It does not mention return values or behavior. For a 2-param tool with no nested objects, the description is incomplete.

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

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

Schema coverage is 100%, so basic param info is already present. The description adds context about supported file types beyond the schema but does not elaborate on the 'query' parameter or file_path format beyond what is already defined.

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

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

The description clearly states the verb 'annotate' and the resource 'file', and lists supported file types (PDF, PNG, JPEG, MD, TXT). It distinguishes from sibling tools like AxDocumentParser_parse_pdf_to_md which converts formats rather than analyzing.

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

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

No explicit guidance on when to use this tool versus alternatives like the parser or analysis tools. The supported file types hint at scope but no context on exclusions or prerequisites.

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

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

No annotations, so description carries full burden. It discloses that the tool collects feedback parameters and is a read-only reporting action. Behavior is transparent, though no side effects are discussed.

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?

Concise, well-structured with bullet points. Front-loads the purpose and immediately states usage. Every sentence is essential.

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?

Lacks information about the tool's return value or side effects. Without an output schema, the description should explain what the feedback tool does with the input (e.g., logs, returns confirmation). This is a notable gap.

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

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

Schema coverage is 100%, but the description adds value by listing required fields in a structured list and explaining their purpose. It clarifies the expected usage 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 clearly states it summarizes a tool call after using any other tool. The name 'report_feedback' is explicit. However, multiple siblings share the same suffix (e.g., AxEquationExplorer_report_feedback), so it lacks 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?

Explicitly says 'Always call this after using any other tool,' providing clear usage context. No mention of when not to use or alternatives, but the directive is strong and unambiguous.

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

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

Without annotations, the description carries the transparency burden. It discloses output file naming and image directory, but does not state whether the original file is preserved, specify error handling, or detail the conversion process beyond 'advanced OCR'. Some behavioral aspects remain unclear.

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

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

The description is two succinct sentences, front-loading the purpose and then detailing output behavior. No unnecessary words or repetition.

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

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

For a simple tool with one parameter and no output schema, the description covers basic usage but omits key details like return value (does it return file path or content?), supported PDF types, and error scenarios. This leaves some ambiguity for invocation.

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

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

With 100% schema coverage and a single straightforward parameter (file_path), the description adds no additional meaning beyond the schema's 'absolute path to the PDF file to analyze'. 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?

The description clearly states the tool converts PDF to markdown using OCR, specifying the verb (convert), resource (PDF to markdown), and technology (OCR). It effectively distinguishes itself from sibling tools like AxDocumentAnnotator_annotate_file or AxDocumentParser_report_feedback.

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

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

No guidance is provided on when to use this tool versus alternatives, nor are there prerequisites, limitations, or exclusions mentioned. The description lacks context for decision-making.

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 exist, so the description carries the full burden. It does not disclose behavioral traits such as state modification, safety, or error behavior. The purpose is clear but lacks transparency beyond the basic function.

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 relatively concise and front-loaded with the core purpose. The inline bullet list of parameters is useful but could be streamlined to avoid redundancy with the schema.

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

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

For a simple feedback tool with 100% parameter coverage and no output schema, the description provides sufficient context. It explains the tool's role and expected inputs, though it could mention safety or idempotency.

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 schema already documents parameters. The description adds some context (e.g., 'feedback can be a short summary'), but largely mirrors schema descriptions. 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?

The description explicitly states the tool is for summarizing the just-executed tool call, using the verb 'Summarize' and specifying the resource ('tool call'). It distinguishes itself from sibling tools as a feedback/reporting tool.

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

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

The description provides explicit guidance: 'Always call this after using any other tool.' This clearly indicates when to use it, though it does not discuss when not to use it or mention alternatives.

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

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

No annotations provided. The description only mentions validation and corrections without detailing side effects, permissions, or whether it auto-corrects. The behavior of providing corrections is vague.

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

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

Two sentences, but the first includes a meta-instruction ('Ask the agent...') which is redundant. Could be more 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?

No output schema. The description fails to specify what the tool returns (e.g., boolean, suggestions). This is a significant gap for a validation tool.

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

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

Schema coverage is 100% and description adds no additional meaning beyond the schema. Baseline of 3 is appropriate as description does not improve parameter understanding.

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

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

The description clearly states the tool validates equations and corrects errors, using a specific verb and resource. However, it does not differentiate from sibling tools like 'find_functional_form' or 'report_feedback'.

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 (e.g., 'AxEquationExplorer_find_functional_form'). No when-not-to-use or prerequisites mentioned.

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

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

Without annotations, the description carries full burden for behavioral disclosure. It states the tool will derive an expression but does not describe what it returns (no output schema), any side effects, authentication needs, or error conditions. The behavior is minimally explained.

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

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

The description is two sentences with no extraneous information. It is concise and front-loaded with the main 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?

Given the lack of output schema and annotations, the description is incomplete. It does not explain what 'derive' means operationally, what the output looks like, or how the document is processed. For a tool that likely generates an expression, more context is needed.

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 baseline is 3. The description adds a hint about providing a description of the expression, but it does not add significant meaning beyond the schema for the 'task' and 'document' parameters.

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

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

The description uses the verb 'derive' and specifies the resource as 'expression of your interest' from source documents, which aligns with the tool name 'find_functional_form'. It is clear what the tool does, but it does not explicitly differentiate from sibling tools; however, the context signals show its uniqueness.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or context that would help an agent decide when to invoke it.

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

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

No annotations are provided, so the description bears full responsibility. It explains what the tool does (summarize previous call) and lists expected inputs. It does not cover side effects or error conditions, but for a logging/report tool this is adequate.

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

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

The description is front-loaded with the main purpose and uses a bullet list for clarity. It is reasonably concise, though the bullet points could be slightly more 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?

The description lacks information about the tool's return value or output. Given that it has no output schema, the description should explain what the tool returns. Also, there is no unique context differentiating it from sibling feedback 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 baseline is 3. The tool description adds value by grouping the parameters and providing context (e.g., 'feedback_value: one of positive, negative, neutral'), going beyond the schema's individual descriptions.

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

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

The description clearly states the tool's purpose: to summarize the previous tool call. It provides a list of required fields. However, it does not differentiate from sibling report_feedback tools (e.g., AxDocumentParser_report_feedback) which likely have identical descriptions.

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

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

The description explicitly says 'Always call this after using any other tool,' providing clear when-to-use guidance. It does not explicitly state when not to use or provide alternatives, but the context makes it sufficiently clear.

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

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

With no annotations provided, the description carries the full burden, and it fully discloses behavior: it returns aggregate statistics, sorts by entity label descending, and covers only the curated corpus. There are no hidden side effects or unspecified scoping concerns for this zero-parameter 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?

Three well-organized sentences: the first states the operation and output, the second gives the use case, and the last draws the key distinction from the private-graph alternative. Every sentence earns its place and there is no redundancy.

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

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

For a simple no-argument read tool with no output schema, the description covers what is returned, the ordering, the scope limitation, and the relevant alternative. Nothing essential is missing for an agent to select and invoke it correctly.

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

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

The tool has zero parameters and 100% schema coverage, so there is nothing for the description to clarify semantically. Per the baseline for zero-parameter tools, a 4 is appropriate because no additional parameter explanation is needed.

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

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

The description names a specific verb ('Retrieve'), a precise resource ('corpus-level statistics for Axiomatic's curated knowledge base'), and the concrete output (total node count and entity-label breakdown). It also distinguishes itself from the private-graph sibling by name, so an agent can tell them apart without inspecting schemas.

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

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

The description explicitly states when to use it ('getting oriented before searching', answering 'what's in the knowledge base') and gives an explicit exclusion: for the organization's private graph use get_private_knowledge_base_overview. This is clear routing guidance with no ambiguity.

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

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

With no annotations provided, the description carries the full burden. It indicates a read-only retrieval action ('Retrieve') and describes the returned content, but it does not disclose other behavioral traits such as output format, permissions, or side effects. The description is adequate but not rich.

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

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

The description is two sentences with no filler. The action is front-loaded, the content is specific, and the secondary sentence adds a clear use case without redundancy.

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

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

For a zero-parameter retrieval tool, the description sufficiently explains what the tool returns (entity types, properties, relationship types, connections) and why it is useful. It does not specify the exact return format, but this is not critical given the tool's simplicity and the absence of an output schema.

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

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

The tool has zero parameters, so the baseline is 4. The description correctly avoids parameter-related information, and the input schema is empty, so there is nothing more 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?

The description clearly states the verb ('Retrieve') and resource ('knowledge base schema'), and details the contents (entity types with properties, relationship types with properties and connections). It does not explicitly differentiate from sibling tools like get_knowledge_base_overview or knowledge_graph_read, 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?

The phrase 'Useful for understanding what kinds of information the knowledge base holds' implies a context of use, but it does not specify when to choose this tool over alternatives or mention any exclusions. There is no explicit guidance about when not to use it.

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

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

With no annotations, the description carries the behavioral burden. It discloses ordering ('largest first'), the aggregate output ('total node count'), the default scope ('every paper... regardless of who ingested it'), and the effect of self_only=True. This is meaningful behavioral detail beyond the schema, though it does not cover possible error or empty-result behavior explicitly.

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

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

The description is compact and well-structured. The first sentence states the core output, the second provides usage context, and the third clarifies the parameter behavior. Every sentence earns its place with no fluff or repetition.

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

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

For a simple one-parameter overview tool with no output schema, the description is largely complete: it explains what is returned, the ordering, the total count, when to use it, and the parameter behavior. It could briefly clarify the return structure or handle the empty-graph case, but those are minor gaps.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds some value by restating the default behavior and how self_only=True changes scope, but the schema already documents the parameter clearly. The added meaning is useful but not substantial enough to push higher.

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 identifies the tool's purpose: returning node counts per entity label in the private knowledge graph, ordered largest first, with the total node count. It distinctly frames this as an overview of the private graph, separating it from sibling search, list, and graph-read tools.

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

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

The description explicitly tells the agent when to use it: 'Use it to see what the private graph holds — including whether it holds anything at all — before searching or querying it.' It does not explicitly name alternatives or exclusions, but the usage context is clear, so it earns a 4 rather than a 5.

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

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

With no annotations provided, the description fully carries the transparency burden. It discloses that the tool is synchronous and slow (takes minutes), idempotent (re-sending safe and reported as already present), and that it writes only to the private graph. These are behavioral traits beyond the schema and are clearly stated, giving the agent confidence in handling long-running or retry scenarios.

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

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

The description is two paragraphs, front-loaded with the primary purpose and scope. Each sentence adds value: the first paragraph covers the action, scope, and uniqueness; the second covers runtime behavior and retry safety. There is no redundant or filler text.

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

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

For a tool with two parameters, no output schema, and no annotations, the description is remarkably complete. It explains the processing pipeline, storage, searchability, performance characteristics, and failure recovery. An agent has everything needed to invoke it correctly and understand consequences.

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% for both parameters: file_path is described as 'The absolute path to the PDF file to ingest' and doi as 'The paper's DOI, if known. Leave empty if unknown.' The description adds no additional parameter-level semantics, but since the schema already covers them, a 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?

The description states a specific verb ('Ingest'), a precise resource ('one local PDF into the organization's private knowledge graph'), and details the processing (parsed into passages, figures, tables, references) and storage. It also explicitly differentiates from siblings by being the only write tool to a knowledge graph and scoping to the private graph, leaving no ambiguity about its role.

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

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

It clearly implies when to use this tool (when writing to the knowledge graph) and explains the downstream effects (reachable via search_private_knowledge_base and private_knowledge_graph_read, never via search_knowledge_base). It also advises on retry behavior after timeouts. However, it does not explicitly name alternatives or conditions for not using it, though there are no direct alternative write tools among siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it does so thoroughly. It states that only MATCH/RETURN is permitted, that rows carry no provenance and must include a paper_id/doc_id column, that the whole result comes back in one response, that long values are elided, and that embedding_* properties and bulk Passage.text should be avoided. It also warns that values without a paper_id are uncited and must not be presented as sourced. This is rich behavioral context beyond what any schema could convey.

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

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

The description is long but every sentence earns its place: it covers purpose, usage, constraints, query patterns, provenance requirements, and performance guidance. It is front-loaded with the core purpose and the when-to-use statement, then moves into constraints and examples. It is somewhat dense and could be trimmed, but the density is justified given the complexity of the tool and the lack of annotations. The example query is valuable and not redundant.

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

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

Given the tool's complexity (a raw Cypher query interface with no output schema and no annotations), the description is remarkably complete. It covers the query language constraints, the required aliasing pattern, the provenance requirement, the performance limits, and the relationship to sibling tools. An agent has everything it needs to invoke the tool correctly and interpret the results. The only minor gap is that it doesn't describe the exact response format, but the description explicitly says 'return the rows' and the example makes the shape clear.

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 (query and params). The description adds significant meaning beyond the schema: it explains what a valid query looks like (MATCH/RETURN only, alias properties, alias from/to for relationships, include doc_id/paper_id), and it clarifies the purpose of params ('for safe value injection'). This goes beyond the baseline 3 because the description provides query-shaping rules that are essential for correct invocation.

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

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

The description states a specific verb ('Execute a read-only Cypher query'), a specific resource ('against the knowledge graph'), and the expected output ('return the rows'). It also explicitly contrasts with the sibling tool search_knowledge_base, which returns prose passages, making the distinction clear. The description is not a tautology and provides enough detail for an agent to know exactly what this tool does.

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

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

The description explicitly says when to use this tool ('when the answer has to be a table of entities and their properties — comparing devices across metrics, building a dataframe, plotting') and contrasts it with the alternative ('rather than the prose passages search_knowledge_base returns'). It also provides a clear prerequisite: 'Call get_knowledge_base_schema first to learn the available labels and property names.' This is explicit when-to-use guidance with an alternative named.

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 does well: it discloses the default all-papers scope, the self_only restriction, ordering by most recent first, pagination, and that total_pages appears in the structured result. This goes well beyond a bare 'list papers' statement.

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

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

The description is front-loaded with the core purpose, then gives default behavior and pagination guidance in a tight, well-structured format. Every sentence adds value and there is no redundant filler.

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

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

For a simple read-only listing tool with three optional parameters and no output schema, the description provides everything an agent needs: output fields, ordering, default scope, filtering option, and pagination handling. It is complete without needing to describe a formal return schema.

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

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

Schema coverage is 100%, so the schema already documents all three parameters. The description adds useful behavioral context by explaining that the default lists every paper regardless of ingestor and by connecting the self_only flag to caller-personal ingestion, plus the pagination workflow via total_pages.

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

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

The description opens with a specific verb and resource: 'List the papers in the organization's private knowledge graph' with a clear output shape ('title and ingestion date, most recent first'). It also distinguishes itself from search and Cypher query tools, so an agent can tell it apart from the sibling knowledge-base search and read tools.

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

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

The description explicitly states when to use it: 'Use it to see what has been ingested without running a search or a Cypher query.' It also clarifies the default behavior and how to restrict with self_only=True, giving concrete decision guidance for invocation.

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 explicitly states the operation is read-only, that 'Only MATCH/RETURN is permitted,' and enumerates concrete constraints: alias properties, return the source paper, keep an explicit LIMIT, never select embedding_* or bulk Passage.text. This is strong disclosure of behavior beyond a generic 'read' label.

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

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

The description is dense but well organized: purpose, sibling relationship, then syntax rules. It front-loads the core verb and resource, and every rule is actionable with an example. It is slightly long, but for a constrained query language the detail is justified and not padding.

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

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

For a complex Cypher tool with no output schema and no annotations, the description covers the essential execution contract: graph target, allowed query form, result shape through the sibling reference, and schema discovery through get_knowledge_base_schema. It does not enumerate the exact row fields or mention auth/error behavior, but the reference to knowledge_graph_read fills the largest 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 defines query and params; the baseline is 3. The description adds real semantic value for the query parameter by detailing valid query shapes and required conventions (aliasing, source paper, LIMIT, forbidden properties), moving it above baseline. It does not add anything about the optional params object, but the schema covers that.

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

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

The description opens with a specific verb and resource: 'Execute a read-only Cypher query against the organization's private knowledge graph and return the rows.' It also distinguishes itself from the sibling by calling itself 'The private counterpart of knowledge_graph_read' and noting 'different graph.' An agent can identify this tool without needing to inspect sibling schemas.

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

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

It gives clear context and names the relevant alternative ('private counterpart of knowledge_graph_read... different graph') and instructs the agent to 'call [get_knowledge_base_schema] first.' It does not explicitly spell out a when-not-to-use condition, but the private/public contrast and schema-first guidance make the intended usage clear.

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

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

There are no annotations, so the description carries the full burden. It discloses that the tool summarizes a prior call and lists required fields, but it does not say whether feedback is persisted, sent, or simply returned, nor what the tool's response looks like. For a tool that is supposed to run after every call, this lack of side-effect and response information 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?

The description is appropriately sized, with a front-loaded directive and a structured field list. It earns its place but contains some redundancy with the schema and a typo in the enum string, which slightly reduce polish.

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 meta-tool with no annotations and no output schema, the definition covers the inputs well but is incomplete on scope and return behavior. The blanket 'after using any other tool' instruction is not reconciled with the domain-specific sibling feedback tools, and the absence of an output schema means the description should at least hint at what the tool returns. These gaps are material for correct usage.

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 baseline is 3. The description repeats the parameter names and brief descriptions (e.g., 'feedback_value: one of positive, negative, neutral'), but adds no examples, format constraints, or relationships beyond the schema. It adds no semantic value.

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

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

The description opens with a clear directive: 'Summarize the tool call you just executed,' which names the verb and resource. However, it makes no reference to the KnowledgeBase domain or to the fact that several near-identical report_feedback siblings exist, so an agent cannot distinguish this tool from AxPDE_report_feedback or AxTidy3D_report_feedback without relying on the tool name.

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

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

It states 'Always call this after using any other tool,' which is an explicit timing condition, but it is overbroad and provides no exclusions or alternatives. Given the long list of sibling *_report_feedback tools for other domains, the instruction as written could cause an agent to use this tool after calling a non-KnowledgeBase tool, so the scope guidance is misleading.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It clearly states what the tool returns (most similar passages with source and similarity score) and its purpose (semantic search), which implies a read-only operation. It also adds a behavioral note about citing results directlycsss. It does not discuss limitations or edge cases, but for a search tool this is transparent enough.

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

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

The description is two sentences long, with the primary action and resource front-loaded. Every clause earns its place: the first sentence defines the scope, the second explains the output and the use case (citation). There is no redundancy or fluff.

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 two-parameter search tool, the description is complete: it covers what is searched, what is returned, and how the results can be used. There is no output schema, but the description explicitly describes the output components (passages, source, similarity score). It could mention pagination or result ordering, but the schema's limit parameter and the 'most similar' phrasing cover the essential behavior.

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

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

The schema description coverage is 100%, with both query and limit fully described ('Natural language question or topic to search for', 'Maximum number of passages to return (1-50)'). The description does not add parameter-specific meaning beyond what the schema already provides, 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?

The description states a specific verb ('Semantic search') and a well-defined resource ('Axiomatic's curated knowledge base of scientific papers, entities, and prior results'), and clearly distinguishes it from the private-KB sibling by emphasizing 'curated' and 'source (paper id/title)'. It also explains the output (most similar passages with source and similarity score), so an agent can select it without opening the schema.

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

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

The description gives explicit guidance on when to prefer this tool: 'Prefer this over unsourced claims like "this is a standard result"'. This tells the agent to use it when a citable, authoritative source is needed. It does not explicitly name alternatives like search_private_knowledge_base, but the context strongly implies the public/curated scope, so the guidance is clear but not exhaustive.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that results are the most similar passages, each with its source paper for citation, and explains the default graph-wide search behavior plus the self_only restriction. This provides meaningful behavioral context, though it does not mention edge cases like empty results or pagination.

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

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

The description is compact and well-structured. It front-loads the core purpose, immediately contrasts the tool with its sibling, and then clearly explains the default scope and the self_only variant. Every sentence adds meaningful information with no fluff.

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-param tool with no output schema, the description adequately covers purpose, usage, return shape (most similar passages with source paper), and default behavior. It could add a bit more detail about how limit is applied or what happens when no results are found, but these are minor gaps given the overall clarity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining the real-world meaning of self_only: the default searches every paper in the organization's private graph regardless of ingester, while setting self_only=True limits results to the caller's own papers. This contextualizes the parameter semantically.

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

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

The description opens with a specific verb and resource: 'Semantic search over the organization's private knowledge base'. It explicitly distinguishes this tool from Axiomatic's curated corpus and names the sibling search_knowledge_base as the alternative, so an agent can immediately tell them apart.

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

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

The description gives explicit when-to-use guidance: 'Use this to find anything ingested with ingest_pdf_to_private_knowledge_base; use search_knowledge_base for the curated corpus.' It further clarifies the default broad scope and the self_only=True restriction, providing complete routing and selection context.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It fully discloses that execution is asynchronous on a remote Kubernetes job, returns a task_id with nothing simulated yet, has a typical 1-2 minute runtime with a 6-hour hard deadline, requires playground access, and rejects scripts that do not meet import/export requirements before submission at no cost.

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

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

The description is compact yet information-dense: four sentences deliver async behavior, follow-up workflow, validation rules, cost implications, runtime, deadline, and access requirements. Every sentence adds value and the most important fact is front-loaded.

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

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

Given one parameter and an output schema that presumably documents the task_id return, the description is complete enough for an agent to invoke this tool correctly. It covers the async contract, follow-up calls, failure modes, timing expectations, and required access, leaving no material 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 'code' parameter thoroughly, including the import and export requirements. The description reinforces these constraints but does not add meaning beyond the schema; the 'at no cost' detail is behavioral rather than parameter-specific, 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?

The opening line uses a specific verb and resource: 'Submit a Meep script for execution.' It also distinguishes itself from sibling execute_code tools by naming the Meep workflow and explicitly differentiating what happens now ('returns a task_id') versus later ('poll get_simulation_status, then call get_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?

The description gives explicit next-step guidance: poll get_simulation_status, then call get_results. It names the follow-up sibling tools and states the playground-access prerequisite. It does not explicitly say when to prefer this over AxMeep_generate_code, but the execution-vs-generation distinction is strongly implied.

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

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

No annotations exist, so the description carries the full burden, and it delivers rich behavioral context: the generated script imports meep and calls export(name, obj) for each result; scalar results should be requested as printed output because plain Python floats return as opaque pickle; and retry should patch the specific failure rather than regenerate from scratch. These details materially shape what the agent can expect and how it should phrase requests.

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

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

The description is front-loaded with purpose and output, then packs non-execution, retry behavior, export conventions, and a concrete scalar-output caveat into a compact set of sentences. Every sentence earns its place and no redundant phrasing exists.

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

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

Given that an output schema exists, the description does not need to explain return structure; it still covers the essential invocation context: what the tool generates, that it must be followed by execute_code, how to handle a failed run, and how to phrase problem descriptions for better results. This is complete for a code-generation tool of this 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 coverage is 100%, so the baseline is 3; the description adds meaningful semantics beyond the schema by explaining how previous_code and previous_error should be paired for failed-run patching and by advising that naming desired results in problem_description improves output. This goes beyond the schema's straightforward parameter descriptions without providing full syntax-level detail.

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: 'Generate a complete Meep FDTD simulation script from a natural-language problem description.' It clearly differentiates from siblings by naming Meep specifically and by explicitly saying it does not execute anything, which distinguishes it from AxMeep_execute_code and AxTidy3D_generate_code.

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

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

Provides explicit when-to-use and when-not-to-use guidance: 'it does NOT execute anything — run it with execute_code.' It also gives conditional retry guidance by instructing the agent to pass previous_code and previous_error when a run failed, and practical tips for describing desired results, all of which help the agent decide how to invoke the tool correctly.

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

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

With no annotations, the description carries the full burden, and it delivers: it discloses non-blocking early-call behavior, export summarization conventions, inline-image limits, local file writing, returned paths, and that pickled objects are never decoded. These are important behavioral traits beyond the schema.

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

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

The description is compact, front-loaded with the core purpose, and every sentence adds a distinct piece of useful information. The long third sentence is structured with clear clauses and is not wasteful.

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 output schema exists and all parameters are documented, the description covers the essential operational context: prerequisite status check, non-blocking behavior, output formatting, file persistence, and handling of unsupported artifacts. Nothing needed for correct invocation is missing.

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

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

Schema description coverage is 100%, and each parameter already has a clear description covering defaults and meaning. The tool description adds behavioral context around outputs but not much parameter-level detail beyond what the input schema already 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?

The description states a specific verb ('Fetch') and resource ('exports of a completed Meep job'), making the tool's purpose immediately clear. It also distinguishes itself from the sibling get_simulation_status by framing this as the post-completion retrieval step.

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

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

It explicitly instructs the agent to check get_simulation_status first and warns that calling this tool early reports the job as still running rather than waiting. This gives clear when-to-use guidance and names the relevant alternative.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden and does so thoroughly. It explains the polling/waiting semantics, the 120-second per-call cap, the immediate return on terminal state, the maximum chaining policy, and the error_trace handoff—all beyond what the schema implies. The only minor omission is an explicit read-only statement, but the tool's nature makes it obvious.

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

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

Three sentences, each dense with purpose: the first defines the action and wait behavior, the second prohibits common mistakes and sets call limits, and the third handles failure routing. There is zero redundancy and the most important information is front-loaded.

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

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

For a simple polling tool with an output schema, the description covers all operational requirements: terminal detection, wait caps, call chaining limits, and error handling. It even preempts the common failure recovery path by telling the agent how to feed the error back into generate_code. Nothing an agent needs to invoke this correctly 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?

Although schema coverage is 100%, the description adds substantial operational semantics: task_id is tied to execute_code, wait_seconds default and cap are reinforced, and the 'Do NOT loop with wait_seconds=0' rule provides crucial safety guidance. It also links the returned error_trace to generate_code, which is high-value context not present in the schema.

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

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

The description opens with 'Check a Meep job, optionally waiting for it to finish,' which clearly identifies the verb (check), the resource (Meep job), and the distinguishing capability (waiting). It is unambiguously different from siblings like AxMeep_get_results, which retrieves final outputs, and AxMeep_execute_code, which submits jobs.

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

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

The description gives explicit, actionable guidance: pass wait_seconds (capped at 120) to wait, it returns when terminal, a typical 1-2 minute job needs one call, and it explicitly warns against looping with wait_seconds=0 or chaining more than 5 calls. It also spells out the exact integration step for failed jobs, directing the error_trace to generate_code as previous_error.

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

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

With no annotations, the description must disclose behavioral traits. It explains what to submit (previous tool details) but not whether the call is read-only, has side effects, stores feedback, or what it returns. The agent cannot predict the tool's effect beyond 'summarize,' which is insufficient without annotation support.

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

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

The description is compact and front-loaded with the directive, followed by a bulleted list of fields. However, it contains a formatting typo in the feedback_value enum ('[positive", "negative", "neutral"]'), and the list largely duplicates schema information, which slightly reduces its structural quality.

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 low-complexity feedback tool with full schema coverage, the description covers the usage directive and parameter list. But it omits any return-value or side-effect info, and the broad 'after using any other tool' guidance is not module-specific. The optional/required ambiguity and lack of output schema leave some gaps for an agent to infer.

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 baseline is 3. The description repeats the parameter names and meanings already in the schema, adding the enum values and a brief definition of feedback. It adds no new semantic depth and may imply feedback and feedback_value are required when the schema marks them optional with defaults.

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

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

The description clearly states the action: 'Summarize the tool call you just executed.' It identifies the resource (the previous tool call) and the fields to include. However, it does not distinguish itself from the many sibling _report_feedback tools (e.g., AxModelFitter_report_feedback, AxPDE_report_feedback), so it lacks sibling differentiation.

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

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

The description gives an explicit when-to-use rule: 'Always call this after using any other tool.' This is clear context but overly broad, since there are module-specific report_feedback siblings and this tool is named AxMeep_report_feedback. It does not mention which tools it applies to or provide exclusions/alternatives.

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

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

No annotations are provided, so the description carries the full burden. It discloses the sandboxed execution environment, names the available libraries, and states the non-obvious rule that results must be returned through export(name, value). It does not mention timeouts, resource limits, or failure behavior, but the core execution contract is well covered.

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

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

Three sentences, each earning its place: the first defines the execution environment and libraries, the second states the mandatory export call, and the third clarifies typical usage. No fluff or repetition.

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

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

For a single-parameter execution tool, the description is largely sufficient: an agent knows what to pass and what contract the code must satisfy. The main gaps are the absence of return-value details and explicit execution constraints, but these are minor given the tool's simplicity.

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 for the only parameter, code, is 100% and already documents the export() requirement. The description adds useful environment and workflow context, but does not need to add parameter-level detail because the schema fully 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 clearly states the verb 'Execute' and resource 'Python code in a sandboxed environment', and further specifies the available libraries and the export(name, value) contract. It is clear what the tool does and when it fits, though it relies on the tool name and library list rather than explicitly contrasting with sibling execute_code tools.

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

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

The description gives clear usage context: it is typically used to run code produced by generate_code, but also accepts hand-written or modified code. This helps an agent decide when to invoke it, though it stops short of naming alternatives or explicit when-not-to-use 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 provided, the description carries the burden. It discloses that the tool returns executable code and an explanation, and that the code must be executed separately, which is a key behavioral trait. However, it doesn't state potential limitations (e.g., code correctness, dependency requirements) or explicitly note that it does not execute the code itself, though this is implied.

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

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

The description is three concise sentences, front-loaded with the main purpose. Every sentence adds value: what it does, what the user provides, and what it returns. No filler or redundant content.

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

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

The description covers the core essentials: purpose, input (problem description), output (code and explanation), and execution next step. It lacks details on error handling or edge cases, but for a one-parameter code-generation tool with no output schema, it is sufficiently complete for an agent to use correctly.

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

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

The schema has 100% coverage with a clear description for the single parameter (problem_description). The tool description essentially repeats the schema wording ('Describe the model, the data, and what you want to fit') without adding new semantic detail, so it meets the baseline for high schema coverage.

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

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

The description states a specific verb ('Generate Python code'), a specific resource ('fit a parametric model'), and the library ('ax_core.model_fitter'). It clearly distinguishes itself from execution tools like AxModelFitter_execute_code and legacy fitting tools by implying code generation rather than direct fitting.

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

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

The description explicitly instructs that the code must be executed separately using the execute_code tool, providing a clear workflow. However, it does not mention alternative tools like AxModelFitterLegacy_fit_model for direct fitting or when to prefer this over other generate_code tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the legacy status, planned removal, and that behavior is unchanged from the original AxModelFitter. It also explains the conditional sigma requirement (required for MSE, None for MAE) and specifies the return payload as AIC, BIC, and AICc. This is substantial behavioral context beyond the schema, though it does not detail error cases or side effects.

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

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

The description is longer than average but well organized with clear headers: LEGACY TOOL, REQUIRED INPUTS, WHEN TO USE, SIGMA PARAMETER, RETURNS. The legacy front-loading is important for routing decisions. The required-input list is somewhat redundant with the schema, but the extra context sections justify the length.

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 12-parameter tool with no output schema, the description covers the key inputs, the conditional sigma behavior, use cases, and the returned values. Optional parameters like n_obs, df_effective, and include_scale_param are left to the schema, which is acceptable. The returns statement is present but slightly generic ('interpretable model comparison metrics'); a more explicit note about AICc handling would round it out.

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 baseline is 3. The description adds value by clarifying that sigma is required for MSE and None for MAE, and it gives a concrete example (measurement error ±0.1 volts → sigma=0.1). It also enumerates required inputs and links cost_function_type strictly to 'mse' or 'mae'. This goes beyond the schema's descriptions.

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

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

The description opens with a specific verb and resource: 'Calculate AIC and BIC information criteria for model selection.' It clearly distinguishes this legacy tool from the new AxModelFitter generate_code/execute_code tools and from sibling metrics tools like calculate_r_squared and fit_model. The legacy framing also prevents confusion with similarly named siblings.

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

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

The description provides an explicit WHEN TO USE section: compare model architectures, select best model complexity, and use lower AIC/BIC values. It also gives clear routing guidance by telling existing workflows to continue using the legacy tool while directing new workflows to the new AxModelFitter server. This is strong alternative-identification.

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 describes a calculation operation but does not explicitly state whether it is read-only or if it modifies any files or state. Given that it's a calculation from inputs (mse, data_file, output_data), it's implied to be non-destructive, but the description doesn't disclose any side effects, error conditions, or permissions. The R² interpretation and examples add contextual value but not explicit behavioral guarantees.

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

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

The description is well-structured with clear sections (legacy warning, simple usage, R² meaning, works with examples). It is somewhat lengthy but each section serves a purpose: the legacy warning is critical for tool selection, the R² interpretation helps the agent assess results, and the examples clarify parameter structure. Information is front-loaded with the legacy note, which is the most important context. It could be tightened, but it's 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?

For a simple calculation tool, the description covers the key aspects: what it does, how to use it (parameter guidance), what the result means (R² interpretation), and when to use it (legacy workflows). It lacks an explicit statement of the return value (e.g., 'returns the R² value as a float'), but that is strongly implied. Since there is no output schema, the description could have been more explicit about the output format, but overall it is quite complete for a calculation 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 the baseline is 3. The description adds value beyond the schema by providing concrete examples for output_data (single and multiple outputs) and explaining the meaning of each parameter in the 'SIMPLE USAGE' section. It also clarifies that all data must be provided via file, which reinforces the data_file description. This goes beyond the schema's basic descriptions.

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

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

The description clearly states the tool's purpose: 'Calculate R-squared to measure how well your model fits the data.' It names the exact metric and explains its interpretation. It also distinguishes itself from the new AxModelFitter tools by labeling itself as the legacy continuation, which differentiates it from siblings like AxModelFitter_generate_code.

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

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

The description explicitly says existing workflows should continue using this tool, while new workflows should prefer the new AxModelFitter server's generate_code/execute_code tools. It also says 'Use this to quickly assess if your optimization produced a good fit,' giving a clear use case. However, it does not mention alternatives within the legacy toolset, such as calculate_information_criteria, which could be a better choice for model comparison.

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 provides important context: the tool is an unchanged legacy continuation subject to removal, all data must come via file, and sigma is conditionally required for MSE vs MAE models. It also previews the return concept (ranked models, AIC/BIC, Akaike weights), though it omits side-effect/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?

The description is well-organized with labeled sections (LEGACY TOOL, USE CASE, REQUIRED INPUTS, EXAMPLE, RETURNS) and front-loads the important migration warning. It is somewhat wordy, with minor repetition between the opening and the use case, but remains scannable.

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

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

The description covers purpose, usage, required inputs, an input example, and return semantics, which is substantial for a tool with no output schema. Advanced statistical parameters (n_obs, df_effective, scaling flags) are left to the schema, so the description is complete but not exhaustive.

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

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

Schema descriptions cover all 10 parameters, so the baseline is 3, but the description adds a REQUIRED INPUTS section and a concrete 'EXAMPLE MODELS INPUT' that clarifies the nested models structure and the conditional sigma rule. This extra guidance helps an agent construct a valid call.

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

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

The description opens with a direct verb-resource statement: 'Compare multiple models to find the best one using statistical criteria,' then grounds it in a concrete use case (competing linear/exponential/polynomial models on the same data). This clearly separates it from fitting or criteria-calculating 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?

It explicitly states when the legacy tool should be used ('existing workflows...should continue to use it') and when it should not ('For NEW workflows, prefer the new AxModelFitter server'), with a removal notice. The USE CASE paragraph names the exact scenario that should trigger this tool.

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

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

No annotations are provided, so the description carries the full burden. It discloses the estimation methods (Huber-White sandwich estimator and classical inverse Hessian), which is useful behavioral context. It also states required inputs and return values. However, it doesn't disclose potential failure modes, computational cost, or what happens if the model wasn't fit with this toolset, and it doesn't mention that this is a read-only computation (no mutation side effects). The method disclosure is meaningful but not comprehensive.

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

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

The description is well-structured with a clear legacy warning up front, followed by a concise purpose statement, method details, usage instruction, and required/return summary. The legacy migration notice is somewhat long but earns its place given the tool's deprecation status. The use of bold labels (REQUIRED, RETURNS) improves scannability. Minor redundancy: 'Compute parameter covariance matrices' and 'RETURNS: Covariance matrices' repeat the same information.

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

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

For a complex tool with 15 parameters and no output schema, the description covers the essential context: what it does, when to use it, what inputs are required, and what it returns. The legacy migration guidance is valuable context. However, it doesn't describe the structure of the returned covariance matrices or how they relate to the parameter order, and it doesn't mention any prerequisites beyond 'fitted parameters' and 'same data'. Given the tool's complexity, a bit more detail on expected output format would improve completeness.

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

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

Schema description coverage is 100%, so the schema already documents all 15 parameters. The description adds the key semantic constraint that 'same data used in fitting' is required, which is critical for correct use. It also mentions 'variance estimate' as required, which maps to the variance parameter. However, it doesn't explain how parameters, bounds, and data_file interrelate beyond what the schema already says, so the added value is moderate.

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

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

The description clearly states the tool computes parameter covariance matrices for fitted model parameters, with a specific verb ('Compute') and resource ('parameter covariance matrices'). It also names the sibling alternative (new AxModelFitter server's generate_code/execute_code) and distinguishes the legacy toolset. However, it doesn't explicitly contrast with the closely related sibling AxModelFitterLegacy_calculate_information_criteria or AxModelFitterLegacy_cross_validate_model, so differentiation from all siblings is incomplete.

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

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

The description explicitly says 'Use after fit_model to quantify parameter uncertainty and correlations', giving a clear when-to-use instruction. It also provides a strong when-not-to-use directive for new workflows: 'For NEW workflows, prefer the new AxModelFitter server's generate_code/execute_code tools'. It doesn't explicitly list exclusions for other legacy siblings, but the legacy/new workflow guidance is a clear routing signal.

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 responsibility for behavioral disclosure. It transparently discloses the legacy status and imminent removal, describes the three validation strategies, and explains how to interpret results (R² consistency for overfitting, low average R² for poor fit). It doesn't discuss side effects or state mutations, but for a cross-validation test tool this is less critical—the description covers the core behavior well.

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

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

The description is long but well-structured with clear section headers (LEGACY TOOL, REQUIRED INPUTS, VALIDATION TYPES, TYPICAL USAGE, INTERPRETATION). The most critical warning (legacy status) is front-loaded cars. Each section earns its place—even the legacy notice is actionable information for tool selection. It's slightly verbose but not padded, and the structure aids readability for an agent.

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

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

Given the tool's complexity (20 parameters, 8 required, no output schema), the description is reasonably complete. It explains the overall workflow (use same params as fit_model, choose validation strategy, interpret R²), and it implicitly conveys the return type by mentioning 'test R² values across folds.' Details like custom_splits structure and optimizer_config are left to the schema, which is acceptable given 100% schema coverage. Minor gaps: it doesn't explicitly state what the tool returns, but this is inferred.

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 baseline is 3. The description adds meaningful usage context beyond the schema: it groups required inputs into a conceptual set ('All model parameters... data_file, input_data, output_data'), explains validation_strategy options in plain language, and provides typical values (n_splits=5, 'kfold' as a good default). This practical guidance helps choose and configure parameters correctly, earning a 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 opens with a clear, specific verb phrase: 'Test how well your model generalizes to new data using cross-validation.' This directly states the tool's purpose and differentiates it from siblings like fit_model (which fits) and calculate_r_squared (which measures fit quality). The legacy warning further distinguishes it from the new AxModelFitter server tools, reducing ambiguity.

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

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

The description provides explicit usage guidance: a REQUIRED INPUTS section (same as fit_model), a VALIDATION TYPES section explaining available strategies, and a TYPICAL USAGE section with concrete steps (e.g., set validation_strategy='kfold' and n_splits=5). It clearly implies when to use this tool (to assess generalization before deploying a model) and when to prefer the new server for new workflows. It lacks explicit 'when not to use' statements beyond the legacy note, but the context is sufficient.

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

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

No annotations are provided, so the description carries the full burden. It discloses meaningful behavioral traits: legacy status with removal in the next major release, the hard constraint that 'All data MUST be provided via files - no direct data input,' the mandatory jnp-only function requirement, and the requirement that bounds cover ALL parameters, inputs, and outputs. It stops short of disclosing side effects (e.g., where result files are written) or failure modes, but covers far more than the typical description.

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?

Well-organized with clear section headers (LEGACY TOOL, REQUIRED INPUTS, DATA MAPPING EXAMPLE, FUNCTION REQUIREMENTS, RETURNS) and front-loaded with the most decision-critical information (legacy routing). It is long, and the data-mapping example partially duplicates schema examples, but for a 16-parameter legacy tool the length is largely justified.

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

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

For a complex tool (16 params, 8 required, nested objects, no annotations, no output schema), the description covers the critical workflow: legacy routing, file-only input, required inputs, JAX constraints, pint units, bounds, and return values. The main gap is the relationship between function_source and the required function_name (whether the source must define a function with that name), which is not explained anywhere.

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% with richly exemplified parameter descriptions, so the baseline is 3. The description adds genuine value beyond the schema by enumerating the required-input workflow, clarifying the cross-parameter invariant that bounds must cover every parameter/input/output, and stating what the tool returns. Minor flaw: its 'REQUIRED INPUTS' list omits model_name and function_name, which the schema marks as required.

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: 'Fit a custom JAX mathematical model against experimental data.' The legacy banner explicitly names the replacement (new AxModelFitter server's generate_code/execute_code) and the sibling family it belongs to, so an agent can distinguish it from both the new toolset and other legacy siblings like cross_validate_model or compare_models.

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

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

Gives explicit routing guidance: 'existing workflows built on this toolset should continue to use it' and 'For NEW workflows, prefer the new AxModelFitter server's generate_code/execute_code tools.' This tells the agent exactly when to select this tool versus the named alternative, with nothing 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 burden. It discloses that this is a read-only example retrieval tool (returns templates, no side effects mentioned), and it discloses the legacy status and removal timeline. However, it doesn't describe what the actual output format looks like (e.g., whether it returns code blocks, file paths, or text), nor does it mention any rate limits or auth requirements. The legacy context is valuable but the behavioral detail 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?

The description is well-structured with a clear legacy warning up front, followed by a concise list of what the examples include and a usage hint. The legacy notice is somewhat verbose (three sentences) but earns its place given the migration context. The bullet-style list is scannable. Minor redundancy: 'LEGACY TOOL' and 'legacy model fitter' repeat the same point.

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

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

For a zero-parameter, no-output-schema tool, the description covers the key context: what the tool returns, what the templates include, and how to use them. The migration guidance is complete with the alternative tool names and console script. The only gap is the lack of detail on the exact return format (e.g., are these code snippets returned as strings? file paths?), but given the simplicity of the tool, this is a minor omission.

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

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

The tool has zero parameters, so there are no parameter semantics to document. The description compensates by explaining what the returned examples contain (JAX syntax, pint units, parameter bounds, file-based data structures), which is the closest relevant semantic content. Baseline 4 for zero params is appropriate.

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

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

The description clearly states the tool returns complete working examples for model fitting with the legacy model fitter, listing specific template types (exponential decay, polynomial, multivariate). It distinguishes itself from the new AxModelFitter server tools by explicitly labeling itself as LEGACY and naming the preferred alternative. However, it doesn't explicitly contrast with sibling tools like AxModelFitter_generate_code or AxModelFitterLegacy_fit_model, so it's not a perfect 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 gives explicit when-to-use guidance: existing workflows built on this toolset should continue to use it, while NEW workflows should prefer the new AxModelFitter server's generate_code/execute_code tools. It also names the console script `axiomatic-modelfitter` and warns about removal in the next major release. This is clear routing guidance with alternatives named.

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. The description discloses that this is a reporting/feedback tool (not a primary action tool), and it specifies the required fields. However, it doesn't disclose what happens after feedback is submitted (e.g., whether it affects model training, whether it's stored, or whether it returns a confirmation). For a feedback-reporting tool, this is a moderate gap, but the core behavior—collecting and reporting feedback—is clear.

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

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

The description is well-structured with a clear opening directive, followed by a bulleted list of fields. It's appropriately sized for a tool with 5 parameters. The only minor issue is the formatting inconsistency in the feedback_value enum list (missing closing quote: [positive", "negative", "neutral"]), which is a small blemish but doesn't significantly harm clarity.

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 feedback-reporting tool with 5 parameters and no output schema, the description covers the essential context: when to call it, what fields to include, and what the feedback_value options are. It doesn't explain the return value or downstream effects, but for a reporting tool this is less critical. The description is complete enough for an agent to call it correctly after any other 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 the schema already documents all five parameters. The description adds value by explaining the purpose of each field in context (e.g., 'previous_called_tool_name: the name of the previous tool called'), which reinforces the schema. However, it doesn't add meaning beyond what the schema provides—it essentially restates the schema descriptions. Baseline 3 is appropriate given full schema coverage.

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

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

The description clearly states the tool's purpose: to summarize the tool call just executed, and explicitly says to always call it after using any other tool. It lists the exact fields to include, making the tool's function unambiguous and distinct from siblings like AxPDE_report_feedback or AxKnowledgeBase_report_feedback, which are domain-specific variants of the same feedback pattern.

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

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

The description explicitly states when to use the tool: 'Always call this after using any other tool.' This is a clear, unambiguous usage directive. It also implicitly distinguishes it from the domain-specific report_feedback siblings by being the generic version, though it doesn't name alternatives explicitly. The 'always' directive is strong enough to guide an agent's tool selection.

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

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

With no annotations, the description carries the transparency burden, and it does explain that the tool summarizes a prior call and lists the expected payload. However, it does not state whether feedback is persisted, what the tool returns, or confirm it has no side effects; those gaps keep it at a mid score.

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

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

The description is compact, front-loads the core directive, and uses a clear bullet list. Minor flaws are the overbroad 'always call' sentence and a quote typo in the feedback_value values.

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 feedback tool, it covers the input fields well and is mostly callable as-is. It does not clarify which sibling report_feedback tool to use, and it treats all listed fields as 'include' rather than distinguishing the three required from the two optional.

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

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

The input schema already describes all five parameters (100% coverage), so the baseline is 3. The description mirrors the schema's field descriptions without adding serialization expectations or examples, such as how to encode previous_tool_parameters or previous_tool_response as strings/null.

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

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

The description clearly states the tool's job with a specific verb and resource: summarize the previous tool call, and it enumerates the fields to include. It does not explicitly distinguish this from the many sibling *_report_feedback tools, so it misses the top score.

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

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

It provides an explicit timing rule ('Always call this after using any other tool'), but that rule is overbroad and unhelpful given numerous sibling feedback tools for different subsystems. It fails to say when to choose this AxPaperSearch report_feedback over AxTidy3D_report_feedback or another variant, and gives no exclusions.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It does state what the tool returns (titles, authors, abstracts, direct PDF links) and implies an external search operation. However, it does not mention potential limitations such as network requirements, result truncation, or differences between preprint and published literature, leaving some behavioral ambiguity.

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

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

The description is two sentences with no filler. The first sentence front-loads the action and output, and the second adds concrete use cases. Every clause earns its place.

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

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

For a simple search tool with 100% schema coverage, the description covers the essential context: what it searches, what it returns, and when it is useful. There is no output schema, but the description names the return fields. It could add a direct note on how it differs from OpenAlex search, but that is not necessary for calling the tool correctly.

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

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

Schema description coverage is 100%, so the input schema already documents all four parameters and their defaults. The tool description adds no additional parameter-level meaning beyond saying 'matching a query,' which is consistent with the baseline 3 for fully covered schemas.

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

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

The description opens with a specific verb and resource: 'Search arXiv for preprints matching a query.' It also names the returned content—titles, authors, abstracts, and direct PDF links—so an agent can clearly tell this is an arXiv-specific paper search. This distinguishes it from the sibling AxPaperSearch_search_openalex even without explicitly naming that alternative.

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

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

The description gives clear usage context: it is 'useful for finding the primary source of a claim, or for downloading papers to use as context instead of relying on memorized standard results.' It does not explicitly state when not to use it or compare it with alternative search tools, so it falls short of a 5, but the intended use cases are clear.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns scholarly works with citation counts, which is useful behavioral information. However, it does not describe the result format, pagination, ordering, or any rate limits. For a read-only search tool this is adequate but not rich.

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

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

The description is two concise sentences with the primary action front-loaded. Every clause adds value: the main function, the comparison to arXiv, and the practical use case. No wasted words.

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

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

For a simple two-parameter search tool with 100% schema coverage and no output schema, the description covers the purpose, the domain of results, and the practical use case (cross-checking claims and citation impact). It does not explain result ordering or pagination, but these are minor for a search tool with a 'limit' parameter.

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%: both 'query' and 'limit' are documented in the input schema. The description adds no parameter-specific details beyond what the schema provides, 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?

The description clearly states the verb 'Search' and the resource 'OpenAlex for scholarly works', and explicitly contrasts with arXiv by noting broader coverage of published venues, DOIs, and citation counts. This distinguishes it from the sibling AxPaperSearch_search_arxiv without ambiguity.

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

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

It provides clear context for when to use the tool: 'cross-checking whether a claim is actually well established in the literature, and by how much it is cited.' It implies arXiv might be preferred for preprints or quick searches, but it does not explicitly state when not to use this tool or name alternatives beyond the implicit arXiv comparison.

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

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

No annotations are present, so the description carries the disclosure burden. It adds useful behavioral traits: 'deterministic, no LLM' and 'Applies the PDE operator symbolically,' implying a pure computation with no external calls. It does not explicitly state absence of side effects or error behavior, leaving some transparency 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?

Two tight sentences front-load the core purpose, add workflow context, and avoid repetition of schema details. Every clause earns its place.

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

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

Given the nested schema and existing output schema, the description covers essential orientation: what it computes, its role in MMS, and the companion tool. It does not walk through parameter formats, but the 100%-covered schema already handles those details, so 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 schema already documents parameters thoroughly with examples and supported coordinate lists. The description adds little parameter-specific meaning beyond referring to 'the supplied solution' and 'PDE operator,' so a 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?

The description opens with a specific verb and object: 'Derive the source term f = L[u] for a manufactured solution.' It clarifies it is deterministic and 'no LLM,' then explains the symbolic application of the PDE operator. Naming 'verify_solution' and calling this the 'forward step' clearly distinguishes the tool from its 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?

It states the tool is the 'forward step of the Method of Manufactured Solutions' and instructs the agent to 'pair it with verify_solution to confirm correctness,' establishing clear when-to-use context. It does not enumerate exclusions or alternatives for other PDE tasks, so it stops short of a full when-not-to-use guide.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that each operator is compile-checked before returning, which is a valuable behavior. However, it does not disclose potential failure modes, whether the operation is stateless, or any side effects. For a parsing tool, this is moderately transparent but leaves some behavioral aspects unstated.

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

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

The description is two sentences, with the core purpose front-loaded in the first sentence, followed by output components and downstream use, and then an exclusion in the second sentence. Every sentence adds value with no redundancy. It is efficient and well-structured.

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

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

The description covers the tool's purpose, input requirements, output components, compile-check behavior, downstream integration, and what it does not do. An output schema exists, so return values are not needed in the description. It is nearly complete for a single-parameter tool; minor gaps like error handling or edge-case behavior are not critical.

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

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

The schema covers 100% of parameters, and the schema's own description of the 'description' parameter is highly detailed, including a concrete example. The tool description adds context about the output structure but does not add new meaning to the parameter beyond what the schema already provides. Baseline of 3 is appropriate since 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 states a specific verb ('parse') and resource ('natural-language or LaTeX PDE description into a structured SymPy spec'), and enumerates the output components (operator code, domain, boundary conditions, variables, unknowns). It also explicitly distinguishes itself from siblings by noting it does not choose a manufactured solution or write a solver, which differentiates it from derive_source and verify_solution.

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

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

The description provides clear usage context by stating the spec feeds directly into derive_source and verify_solution, implying it should be used as a preprocessing step for those tools. It also gives an explicit exclusion ('does NOT choose a manufactured solution or write a solver'), which helps prevent misuse. However, it does not explicitly mention when not to use it in favor of other tools, such as when a structured spec already exists.

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

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

With no annotations provided, the description carries the full burden. It transparently describes that the tool summarizes a prior call and lists the required information (tool name, parameters, response, feedback). It also clarifies the feedback_value options. However, it does not disclose any potential side effects or storage behavior, but for a feedback reporting tool, the description is sufficiently transparent.

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

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

The description is well-structured with a clear purpose statement and a bulleted list of parameters. It is front-loaded with the key instruction. While it repeats schema details, it remains reasonably concise and scannable. The minor typo in the feedback_value list is a small flaw but does not detract much.

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 feedback tool with no output schema, the description is complete. It tells the agent exactly what to include and when to call it. The required parameters are clearly specified, and the optional ones are defined with defaults. There is no missing information that an agent would need 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 coverage is 100%, so the baseline is 3. The description repeats the parameter definitions already present in the schema (e.g., previous_called_tool_name, previous_tool_parameters, previous_tool_response, feedback, feedback_value). It adds minimal extra meaning, though it does emphasize that these should be included. It also lists the feedback_value options, which matches the schema. Overall, it does not significantly go 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 clearly states the tool's purpose: 'Summarize the tool call you just executed.' It also provides the universal trigger 'Always call this after using any other tool,' which makes the action and scope explicit. While it doesn't differentiate from sibling *_report_feedback tools, the domain prefix (AxPDE) and the instruction to call it after any tool give enough clarity.

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

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

The description gives explicit usage instruction: 'Always call this after using any other tool.' This clearly tells the agent when to invoke it, and there is no alternative tool mentioned because this is the designated feedback tool for the PDE domain. It effectively sets the usage pattern.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does well: it states the tool is deterministic, uses no LLM, checks residuals and boundary conditions, and 'fails closed' — meaning anything it cannot check is reported as not passing rather than silently accepted. This is valuable behavioral context beyond what the schema shows. It could add more about error reporting or performance, but the fail-closed behavior is a strong disclosure.

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

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

Three sentences, each earning its place: what it does, the exact mathematical criterion, and the critical fail-closed behavior. The most important information is front-loaded. No fluff or repetition of schema details.

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

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

The tool has 7 parameters, nested objects, and an output schema, and the description covers the core purpose, the mathematical convention, and the fail-closed behavior. The schema covers parameter details. The only minor gap is that the description doesn't mention what the output looks like, but the output schema exists and the description needn't explain return values. Overall it is complete enough for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents all 7 parameters thoroughly. The description itself does not add parameter-level detail beyond the schema, but it does clarify the overall contract (L[u] = f convention, operator_code defines exactly one function). Baseline 3 is appropriate because the schema does the heavy lifting and the description adds only marginal semantic value.

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

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

The description states a specific verb ('Verify'), a specific resource ('a manufactured solution symbolically'), and the exact acceptance criterion ('residual L[u] - f is identically zero for each equation and every boundary condition is satisfied'). It also distinguishes itself from LLM-based checks by noting it is deterministic and 'no LLM', which separates it from sibling tools like AxPDE_parse_pde and AxPDE_derive_source.

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

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

The description clearly implies this is the final verification step of the Method of Manufactured Solutions pipeline, and the 'hard-to-cheat' and 'fails closed' language tells the agent when this tool is appropriate (when rigorous symbolic verification is needed). It does not explicitly name alternatives or state when not to use it, but the context of the MMS pipeline and the deterministic/no-LLM contrast provide clear usage context.

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

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

No annotations are provided, so the description carries full burden. It mentions 'precise numerical data points' but does not disclose limitations such as accuracy, supported plot types (only line/scatter implied), behavior with noisy data, or output format. The description is too brief to adequately inform an agent about behavioral traits.

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

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

The description is a single sentence, front-loaded with the verb 'Analyzes' and resource. It is concise with no wasted words, but could benefit from more structure if expanded. For its length, it is efficient 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?

Given no output schema and no annotations, the description is incomplete. It does not explain return values, error handling, or limitations beyond the schema. For a tool of moderate complexity (2 parameters), more context is needed to understand what the tool produces and how it handles edge cases.

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 baseline is 3. The tool description adds no extra meaning beyond what the schema already provides for plot_path and max_number_points_per_series. No additional context is given for parameter interpretation.

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

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

The description clearly states the tool analyzes images of line and scatter plots to extract numerical data points from all series. The verb 'analyzes' and resource 'images of line and scatter plots' are specific, and the purpose distinguishes it from siblings like AxPlotToData_split_multi_plot which splits multi-plot images.

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

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

The description implies usage for extracting data from all series in a plot but does not provide explicit guidance on when to use this tool versus alternatives like split_multi_plot or when not to use it. No exclusions or context for selection are mentioned.

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

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

No annotations provided, so the description carries full burden. It transparently describes that this tool summarizes a previous tool call, with no destructive or hidden side effects. The behavior is fully disclosed.

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

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

The description is well-structured with the main purpose in the first sentence and a clear list of parameters. It is concise at about 5 sentences, but could be slightly tighter by removing redundant parameter descriptions already in schema.

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

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

For a simple feedback tool with no output schema and full parameter coverage, the description completely explains its role, usage, and required inputs. No gaps remain for effective 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 coverage is 100%, so the schema already documents all parameters. The description adds context by explaining the purpose and example values (e.g., feedback_value enum), but does not add significant meaning beyond what the schema provides. 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?

The description states 'Summarize the tool call you just executed' with a specific verb and resource, clearly indicating its purpose as a feedback/reporting tool. The name includes 'AxPlotToData' which distinguishes it from sibling feedback tools for other agents, though not explicitly differentiated.

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

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

Explicitly instructs 'Always call this after using any other tool,' providing clear when-to-use guidance. It also lists required fields and their expected content, leaving no ambiguity about how to invoke it.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose behavioral traits such as output format, side effects (e.g., temporary file creation), or whether the operation is destructive.

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 key information. Every word serves a purpose with no redundancy.

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

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

Given the tool's simplicity (one parameter, no output schema), the description explains input and operation but omits the output format (e.g., saved paths or returned data). This is a notable 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% with the plot_path parameter well-documented. The description adds no additional meaning beyond the schema, resulting in baseline score.

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

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

The description clearly states the verb 'splits' and the resource 'image of a plot with multiple subplots' into 'individual subplots'. It distinguishes from siblings like AxPlotToData_extract_numerical_series and AxPlotToData_report_feedback.

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. For example, it doesn't mention that splitting should precede extraction nor when not to use it.

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

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

With no annotations to lean on, the description carries the full behavioral disclosure burden. It states that local operations are free and synchronous, that cloud submission returns a cost estimate without starting the run, and that nothing is billed until start_simulation is called. This prevents the agent from mistakenly believing the simulation was launched.

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?

Four tightly written sentences with the purpose front-loaded. Each sentence adds distinct, necessary information: the action, local mode behavior, cloud mode behavior, and the required next step. No filler or redundancy.

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

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

Despite having no output schema, the description compensates by specifying both return paths: synchronous local results via export, and the structured cost-estimate object with task_id, task_status, and estimated_cost_flex_credits. It also names the necessary follow-up tool, making the full workflow clear.

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

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

The single code parameter already has a clear schema description ('Tidy3D Python code to execute'), so the baseline is high. The description adds further meaning by explaining what such code can contain, such as export(name, value) and submit_to_cloud(sim), and what those calls return.

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

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

The description opens with a precise verb+resource statement, 'Execute Tidy3D code,' and then clearly explains the two execution modes: local synchronous execution and cloud submission via submit_to_cloud. This distinguishes it from the sibling start_simulation, which consumes the task_id produced here, and from code-generation siblings.

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

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

The description explicitly explains when local execution is appropriate, what happens when code calls submit_to_cloud, and routes the agent to call start_simulation only after user confirmation. This gives the agent a concrete decision path and names the exact follow-up sibling tool.

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

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

With no annotations provided, the description carries the full burden. It discloses that the code must be run separately and that retry logic is supported, which are useful non-obvious behaviors. However, it does not disclose potential side effects (e.g., does generating code consume resources?), error characteristics, or what constitutes a 'previous attempt failed' detection. The disclosure is adequate for a generation tool but not rich.

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

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

The description is two sentences, front-loading the primary purpose and then adding the retry guidance. Every sentence earns its place with no fluff. It could be more structured with a clear when-to-use section, but it is efficient and well-ordered.

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 generation tool with 3 parameters all covered by schema and a clear output description (executable code and explanation), the description is complete enough for an agent to call it correctly. It doesn't mention output format details, but the output schema is absent and the description says 'returns executable code and an explanation', which suffices. The retry guidance fills a common integration 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 adequately documents each parameter. The description adds context that previous_code and previous_error are used for retry fixes, which complements the schema's 'if retrying' hint, but it doesn't add significant new meaning beyond the schema. The main parameter problem_description is well-defined in 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?

The description clearly states the verb 'Generate' and the resource 'Python code for a Tidy3D simulation', specifying supported simulation types (FDTD, mode solving). It distinguishes from siblings like AxTidy3D_start_simulation and AxTidy3D_execute_code by indicating this is generation only. It could explicitly name the sibling for differentiation, 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?

It states when to use this tool: given a natural language problem description, and when to use a variant: when retrying with previous_code and previous_error. It implies that execution is handled separately via execute_code, which guides usage flow. However, it does not explicitly state when to use AxTidy3D_generate_code vs AxMeep_generate_code or when not to use it (e.g., for execution), leaving some inference to the agent.

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

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

With no annotations, the description must carry the full behavioral burden. It reveals that the tool polls status and that cost may only be available 'once known', implying a non-blocking read operation. However, it does not disclose error conditions, whether it blocks, or what happens if the task ID is invalid, which would be useful for an agent.

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

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

The description is a single, front-loaded sentence with no fluff. It states the primary action and an important nuance (cost availability) efficiently, and every word earns its place.

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

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

This is a simple tool with one parameter, but there is no output schema and no annotations. The description does not specify the return format (e.g., what status values look like, cost format, whether it returns a JSON object) or any error handling. An agent would not know what to expect from the result, which is a significant gap for a polling tool.

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

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

The schema already provides a description for task_id ('The task_id to check'), covering 100% of parameters. The tool description does not add any further meaning or usage details for the parameter, so it adds no value beyond the schema. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the action ('Poll the status'), the resource ('a running or completed Tidy3D cloud task'), and an additional outcome ('real cost once known'). This verb-resource pair is specific and distinguishes it from sibling tools like AxTidy3D_start_simulation or AxMeep_get_simulation_status without ambiguity.

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

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

The description provides clear context: it is for checking status of Tidy3D cloud tasks, which implies it is used after starting a simulation. However, it does not explicitly name alternatives or state when not to use it (e.g., vs. AxMeep_get_simulation_status). This is a minor gap but not misleading.

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 full behavioral disclosure. It does not mention side effects, permissions, rate limits, or whether the tool sends data externally. It only lists the fields to include, which is parameter information, not behavioral context. For a tool that reports feedback, it lacks transparency about what happens with the data or any potential consequences.

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 fairly concise but duplicates parameter information already present in the schema. It front-loads the purpose and includes a list of parameters, which adds length without new value. It could be shortened by referencing the schema, but it is not overly verbose. The structure is acceptable but not efficient.

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

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

For a simple reporting tool with 5 documented parameters and no output schema, the description covers the essential action and required fields. However, it does not address the sibling ambiguity (which report_feedback to use) or any edge cases (e.g., what if the previous tool failed). Given the many similar tools, additional context about selection would improve completeness.

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

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

Schema description coverage is 100%, so each parameter is already documented in the input schema. The description repeats the parameter names and brief purposes, but adds no additional meaning beyond the schema. Since coverage is high, the baseline is 3, and the description does not elevate it further.

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

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

The description clearly states the tool's purpose: 'Summarize the tool call you just executed.' It identifies the resource (the previous tool call) and the action (summarize/report). While it doesn't explicitly differentiate from the many sibling report_feedback tools, the tool name includes 'Tidy3D', so it's contextually clear. This is a clear statement of function, though not maximally specific about domain.

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

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

The description explicitly says 'Always call this after using any other tool,' which provides clear when-to-use guidance. However, it does not mention alternatives or clarify which of the multiple report_feedback siblings should be called (e.g., AxModelFitter_report_feedback, AxPDE_report_feedback). The guidance is present but incomplete given the sibling ambiguity.

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

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

The description discloses a critical behavioral fact: this is the only step that spends real Flex credits, which is not in annotations. However, it misses other behavioral details like whether it's read-only or irreversible, or what happens on failure. With no annotations, it partially covers burden but leaves 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?

Description is efficient, with critical cost warning front-loaded. It uses three sentences without fluff. Slight redundancy: 'previously estimated' and later 'estimated_cost_flex_credits' repeat the estimation concept, but overall 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?

For a two-parameter tool with full schema coverage, description covers essential usage flow (estimate, confirm, start). However, missing details on what confirms success or error handling, and no mention of return value. It is sufficient but not exhaustive.

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

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

Schema coverage is 100%, so parameters are fully documented in schema. The description adds context on where task_id comes from (execute_code) and that task_name is optional display, but these are also in schema. Minimal additional value beyond schema.

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

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

The description clearly identifies the tool's action: starting a previously estimated Tidy3D task. It specifies the resource (cloud task) and distinguishes it from other Tidy3D steps (generate, execute, status). However, it doesn't explicitly name sibling tools, 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?

The description provides explicit when-to-use guidance: only after estimated cost has been confirmed by user. It also specifies the prerequisite (task_status must be 'estimated') and reference to the task_id from execute_code, clearly separating this from other Tidy3D operations.

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