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

With no annotations, the description must fully disclose behavioral traits. It explains that assumptions are recorded in MathContext and the session engine, affecting math() calculations. However, it omits details on idempotency, overwriting behavior, error scenarios, or required permissions.

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

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

The description is well-structured with Args, Returns, and Example sections. It is reasonably concise, though it includes internal implementation details (MathContext, SymPy) that may not be essential for an AI 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 and the existence of an output schema, the description covers the core functionality, side effects, and return value. It lacks mention of error handling or validation, but provides sufficient context for typical use.

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

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

Schema description coverage is 0%, but the description compensates with a concrete example showing the expected format (e.g., {'x': 'positive real'}). This adds meaning beyond the schema's bare type definition, though it does not enumerate all possible property values.

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

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

The description clearly states that the tool sets symbolic assumptions affecting subsequent math() calculations. It uses a specific verb (set) and resource (assumptions), but lacks explicit differentiation from similar sibling tools like assume_for_step.

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

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

The description provides no guidance on when to use this tool versus alternatives like assume_for_step, check_assumption_conflicts, or list_assumptions. It does not specify preconditions or scenarios where the tool is appropriate.

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

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

With no annotations, the description carries the burden. It describes input format (alternating strings) and return values (updated assumptions and conflicts), but omits side effects, idempotency, error conditions, or parameter constraints. Adequate but not thorough.

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

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

The description is concise with clear sections (Args, Returns) and an emoji header. However, the inconsistency with the schema detracts from its effectiveness. It is not excessively long but could be more precise.

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

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

With an output schema present, return description is adequate. The parameter description is incomplete due to schema mismatch. Given the complexity of assumption management and many sibling tools, more detail on the expected string 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 coverage is 0%, so description must compensate. It explains that 'args' should be alternating symbol and property strings, which adds meaning. However, there is a mismatch: description implies variadic positional arguments ('*args') while schema defines a single string property. This inconsistency may confuse an AI agent, reducing clarity.

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 tool name 'assume_for_step' and description 'Set assumptions for the current derivation step only' clearly indicate a step-scoped assumption-setting operation, distinguishing it from a global 'assume' tool. The addition of 'only' further emphasizes the scope.

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

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

The description does not mention when to use this tool versus siblings like 'assume', 'check_assumption_conflicts', or 'clear_step_assumptions'. No explicit guidance on alternatives or scenarios where this tool is inappropriate.

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

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

No annotations provided; description indicates read-only query behavior but does not explicitly state it is non-destructive or discuss side effects, though output suggests a report.

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?

Extremely concise: three short sentences with a helpful emoji, 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 no parameters and an output schema, the description is adequate for a simple detection tool, but could mention the report format or schema reference.

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?

No parameters exist, and schema coverage is 100%; baseline for zero parameters is 4, and description adds no parameter info since none are 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 clearly states the tool detects conflicts across assumption levels, defines conflict with an example, and distinguishes from siblings like check_symbol_conflicts by targeting all levels.

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 check_symbol_conflicts, missing 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states the tool performs a check and returns a report with disambiguation suggestions. It does not indicate any destructive side effects, and the behavior (read-only inspection) is well communicated.

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: three short sentences with no wasted words. It front-loads the core action with a warning emoji, defines key terms, and states the return value. Every sentence adds value.

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

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

Given zero parameters and the presence of an output schema, the description is largely complete. It explains the tool's purpose and output. However, it could briefly mention when in the workflow this check is relevant, but that is a minor 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?

The tool has zero parameters, so by guidelines the baseline is 4. The description does not need to add parameter semantics, and it correctly omits them. The empty input schema is fully covered.

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: checking for ambiguous symbols in the current session. It defines what a conflict is (same symbol name with multiple meanings or domains) and mentions the return type (conflict report with suggested disambiguation). This is specific and distinguishes it from sibling tools like check_assumption_conflicts and other symbol-related tools.

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

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

The description implies usage when you need to detect symbol ambiguity but does not explicitly state when to use this tool versus alternatives like check_assumption_conflicts or list_domain_symbols. There is no guidance on when not to use it or prerequisites, leaving the agent to infer context.

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

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

With no annotations, the description carries the burden. It mentions clearing assumptions but lacks details on side effects, idempotency, or session requirements. The return is vague ('Operation result').

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

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

Extremely concise, two sentences plus a returns line. Front-loaded with emoji and clear action, 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 tool with no parameters and a clear purpose, the description covers most needs. It could explain the return value more, but overall complete.

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

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

No parameters exist, so schema coverage is full. Description adds no param info, which is acceptable with 0 parameters. Baseline 4 applies.

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

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

The description clearly states it clears step-level assumptions, using a specific verb and resource. It distinguishes from siblings like 'assume' and 'list_assumptions'.

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 a clear usage context: 'when moving to a new sub-derivation or branch.' However, it doesn't explicitly state when not to use or suggest 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 full burden. It describes the return values and notes that external_sources defaults to all sources and network failures are silently ignored. However, it does not disclose potential side effects (e.g., session creation), authorization needs, or the full behavioral impact beyond the listed parameters.

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

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

The description is well-structured with an emoji lead-in, an Args list, and a Returns line. It is concise, with each sentence earning its place. Could be slightly more compact, but overall 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?

Given the tool's complexity (8 parameters, 1 required) and no annotations, the description is adequate but incomplete. It explains parameters and return values, but does not cover prerequisites (e.g., session existence), error conditions, or the overall flow. The returns are summarized but could be more specific.

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

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

The description provides a comprehensive list of all 8 parameters with one-line explanations, compensating for the 0% schema description coverage. Each parameter is explained in natural language, adding meaning beyond the schema types and default values.

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 is a high-level derivation entry point that starts a derivation from a goal. This specific verb+resource combination distinguishes it from sibling tools like session_start or formula_search, which have different purposes.

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. Siblings include session_start, session_set_goal, and others that could be confused, but the description does not clarify the appropriate context or provide when-not-to-use advice.

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 formulas are persisted as YAML files under a specific directory path, and the return value includes success indicator, formula_id, file_path, and message. It also shows an example. However, it does not explicitly state behavior on update (e.g., whether an existing id triggers overwriting) or any destructive implications, but overall it is transparent about the main 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 well-structured with a clear opening, bullet-point parameter list, and example. It covers all 12 parameters without being excessively verbose. Minor redundancy between domain and category descriptions, but overall it earns its 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?

Given the tool's complexity (12 parameters, nested objects, output schema), the description is remarkably complete. It explains persistence, parameter roles, return value structure, and provides a comprehensive example. The optional library_path and default behavior are covered. The presence of an output schema reduces the burden, but the description still adds value on top.

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

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

Schema description coverage is 0%, so the description must compensate fully. It provides detailed explanations for every parameter: id as filename and lookup key, sympy_str with example, variables as mapping with metadata, domain/category as folder tags, etc. The description adds significant semantic meaning beyond the bare schema titles, making it easy for an agent to populate arguments correctly.

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

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

The description opens with 'Add or update a formula in the local library,' clearly stating both the action and resource. It distinguishes from sibling tools like formula_get or formula_search by emphasizing local library management and manual extension.

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

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

The description says 'This lets you (and the LLM) extend the local formula collection manually,' which provides clear context for when to use. However, it does not explicitly state when not to use this tool or mention alternative tools (e.g., formula_insert if it existed). The usage guidance is adequate but lacks exclusions or comparisons.

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 fully discloses behavior: it lists categories from specified sources, returns a structured JSON with success flag and category lists. It implies a read-only operation without 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 slightly lengthy due to complete parameter and return documentation, but it is well-structured with 'Args' and 'Returns' sections. Every sentence adds value, making it efficient for its completeness.

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 only one parameter and an output schema-like return description. The description fully covers the tool's purpose, parameters, and return structure, leaving no 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?

Despite 0% schema description coverage, the description provides extensive semantics for the 'source' parameter, explaining each allowed value ('local', 'all', 'wikidata', etc.) and their meanings, far exceeding 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 states 'List available formula categories' with a specific verb and resource. It clearly distinguishes from sibling tools by focusing on category listing, which is unique among many siblings.

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

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

The description explains when to use different sources via the 'source' parameter, including defaults and options. However, it does not explicitly state when not to use this tool 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 exist, so description carries full burden. It discloses that loading into session requires an active session started with session_start(). Return format is shown. Safe read operation 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?

Well-structured with Args, Returns, and Example sections. Each sentence earns its place, though default values are redundantly restated from 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?

Complete for the tool's complexity: all three parameters explained, return object detailed, and example usage provided. Output schema exists, so description complements it well.

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

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

Schema has 0% description coverage, but the description fully explains each parameter: formula_id with example, source with enum values and recommendation, and load_into_session with prerequisite. Adds significant meaning 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 states 'Get detailed formula information from the local library'—a specific verb+resource. It distinguishes from sibling tools like formula_search and formula_add by focusing on retrieval and immediate session loading.

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 clear context: use to get formula details, with guidance on source options and loading into session. Lacks explicit when-not-to-use but adequate given sibling diversity.

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 states that the search is 'deterministic, fast, and does not require network access' and mentions automatic normalization of queries. It doesn't mention destructive actions or auth needs, but as a read-only search 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 long but well-organized with sections, examples, and a workflow. It front-loads the purpose and then details parameters and usage. While every sentence is valuable, some repetition in source descriptions could be trimmed.

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

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

Given the complexity (4 parameters, no schema descriptions, output schema present), the description is highly complete. It includes parameter explanations, example workflows, and even a sample return format, leaving little ambiguity for the agent.

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

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

With schema description coverage at 0%, the description must explain parameters. It provides extensive details for each parameter: query (with examples), source (with all valid values), domain (optional with examples), and limit (though minimal). This fully compensates for the lack of schema descriptions.

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

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

The description clearly states 'Search the local formula library' and details the function of retrieving formulas from a YAML library. It distinguishes this tool from siblings like formula_get (which retrieves by ID) by focusing on search functionality and providing a workflow.

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 includes a 'Correct workflow for derivation' that shows when to use this tool as the first step. It also explains different source options (local, scipy, legacy) and recommends 'local' as default. It doesn't explicitly state when not to use this tool, but the workflow suggests it's for initial search, not for retrieving specific formulas already known.

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, but it only lists inputs and output. It does not state whether the tool modifies any state, requires a session, or how it handles invalid inputs or optional verification. This leaves the agent without important context about side effects or error behavior.

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

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

The description is well-structured as a docstring with a clear one-sentence purpose, a concise Args list, and a Returns line. It front-loads the primary action and contains no unnecessary words, making it appropriately sized and easy to scan.

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

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

The description covers basic inputs and output format, but given the nested object parameters and numerous sibling tools, it lacks important context: no usage guidance, no detail on the report's structure, and no mention of whether verification appears in the output. It is adequate but has clear gaps.

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

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

The description adds minimal meaning beyond the schema's bare types: it names each parameter and gives brief hints, such as given and results being dictionaries mapping symbols to values. However, 'steps' is only vaguely described as 'Derivation steps' without specifying the expected structure of each step object. Since schema coverage is 0%, the description partially compensates but not fully.

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

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

The description clearly states the tool generates a complete derivation report in Markdown. It uses a specific verb ('generate') and resource ('derivation report'), and the format is defined, which distinguishes it from sibling tools like generate_latex_derivation and generate_sympy_script.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as needing an active derivation session, or when not to use it. The word 'complete' hints at final reporting, but no direct comparison to siblings is given.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It describes inputs and output but does not explicitly state whether the operation is side-effect-free, whether it validates inputs, or how it handles edge cases. While it implies a pure generation function, this is not explicitly stated.

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

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

The description is a well-structured docstring with Args and Returns sections, containing no unnecessary words. It is succinct and clearly organized, making it easy for an agent to parse.

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 generation tool, the description covers the essential inputs and return value. It does not include examples or edge-case behavior, but the tool's purpose is straightforward and the output schema likely provides additional structure. The description is adequate 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 is 0%, but the description compensates by explaining each parameter: title is the derivation title, steps is a list of {description, latex} objects, and final_result is the final result in LaTeX. This adds meaningful semantic context beyond the raw schema types.

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

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

The description clearly states the tool's function: generating LaTeX documentation for a derivation. It uses a specific verb (Generate) and resource (LaTeX documentation for a derivation), and distinguishes itself from related generation tools by specifying the output format (LaTeX). The Args and Returns sections further clarify the purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives such as generate_derivation_report or generate_sympy_script. It only states what it does, without any contextual or exclusionary information to help an agent choose it over 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?

No annotations provided, so description carries full burden. It discloses the tool assembles expressions into a function without performing calculations, and specifies the return structure. This provides sufficient 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 well-structured with sections, but slightly verbose; the example is helpful but could be trimmed. However, every part adds value.

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

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

Given the tool's complexity and lack of annotations, the description provides a complete picture: purpose, workflow, parameters, return values, and an example. It stands alone without needing supplementary info.

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

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

Schema coverage is 0%, but the description adds detailed parameter definitions and a full example, significantly enhancing understanding beyond the schema titles.

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

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

The description clearly states it generates a Python function from verified derivation steps. It differentiates from siblings by emphasizing no new symbolic calculations, and the example and workflow clarify the purpose.

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

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

Explicitly provides a 4-step workflow with prerequisites, warning that expressions must be verified first. It tells the agent when to call (after verification) and when not to (for new calculations, use other tools).

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It clearly states that the tool generates a script (not executes it), and that the script is standalone and runnable, indicating a read-only generation operation. It also lists supported operation types. It doesn't disclose potential failure modes, but for a generation tool, the core behavior is well covered.

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

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

The description is well-structured with a one-line summary, detailed parameter breakdown, return description, and a clear example. Every sentence adds value, and the formatting (Args/Returns/Example) makes it easy to scan. The length is appropriate for the tool's complexity.

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

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

Given the vague input schema (only arrays of objects) and no annotations, the description provides the necessary context to invoke the tool correctly, including parameter formats, allowed operations, and the return type. The example reinforces the expected usage. The description is sufficiently complete for the tool's complexity.

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

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

Schema coverage is 0%, so the description completely compensates by defining the structure of the 'expressions' list (name, expr, description) and the 'operations' list with supported op values (simplify, solve, diff, integrate) and 'input' field. The example further clarifies how parameters are used, adding significant meaning beyond the bare schema.

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

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

The description clearly states it generates a standalone SymPy script for a computation, with a specific verb and resource. It explains the script is complete and runnable. However, it doesn't explicitly differentiate from sibling tools like derivation_export_for_sympy or generate_python_function, though the 'standalone' phrasing offers some distinction.

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

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

The description implies usage by describing the task (generating a script for a computation) and provides a concrete example, but it never explicitly states when to use this tool versus alternatives or any exclusions. No alternative tools are mentioned, leaving the agent to infer the appropriate context.

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

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

No annotations provided, so description carries full burden. Describes return values but does not disclose side effects, mutability, or safety. Minimal behavioral disclosure beyond core functionality.

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-structured with overview, Args, Returns, and Example. Every sentence is informative and 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 complexity and lack of schema descriptions, the description fully covers purpose, parameters, usage, and return values with an example.

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

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

Schema coverage is 0%, but description provides detailed explanations for all four parameters, including examples, defaults, and optionality, adding significant 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?

Clear verb 'map' and 'recommend', specific resource 'tool chain', and distinguishes from sibling tools like derive and tool_recommend by being a natural-language intent router.

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?

Implies usage for natural language intents and executing recommended tools, but does not explicitly state when not to use it or differentiate from alternatives like tool_recommend.

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 read-only operation but does not explicitly state side effects (or lack thereof). It does not mention authorization needs, rate limits, or other behavioral traits beyond listing.

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 exceptionally concise with two sentences and a returns line. It is front-loaded with the purpose and efficiently explains the parameter and output without unnecessary detail.

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

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

Given the tool's low complexity (one optional parameter, has output schema), the description is complete. It explains what the tool does, how to use the parameter, and what is returned.

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

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

Schema coverage is 0%, but the description's Args section clearly explains the 'level' parameter with enumerated options ('global', 'domain', 'session', 'step', or None for merged). This adds significant meaning beyond the schema's generic anyOf definition.

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

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

The description clearly states the action 'List assumptions' and specifies the resource ('assumptions at a specific level or merged across all levels'). It distinguishes from sibling tools like 'assume' and 'show_assumptions' by focusing on listing with level granularity.

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

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

The description implies usage when needing to list assumptions at different levels, but does not explicitly state when to use this tool over alternatives like 'show_assumptions' or 'check_assumption_conflicts'. No exclusions or when-not-to-use guidance provided.

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

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

No annotations are provided, so the description must reveal behavioral traits. It only states 'list default symbols' but doesn't mention whether the list is exhaustive, side effects, or auth requirements.

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

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

The description is concise with a docstring format (Args, Returns). It is front-loaded and contains no unnecessary 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?

An output schema exists, so return values are covered. However, the description lacks usage context and parameter details. Adequate for a simple list operation but has gaps.

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

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

Schema description coverage is 0%. The description adds minimal meaning: 'Domain name' for the parameter. The schema already has name and type, and a default. Little value added.

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

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

The description clearly states the verb 'List' and resource 'default symbols for a given domain'. It distinguishes from siblings like 'lookup_symbol' and 'register_symbol'.

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. The description only states what it does, not the context or conditions for use.

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 information (descriptions, typical steps, suggested operations) but does not explicitly state behavioral traits such as read-only nature, side effects, or performance characteristics. Since the tool has no parameters and no destructive effects are implied, the description is minimally adequate but could be more 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 extremely concise, with two short sentences that immediately convey the purpose and return value. It is front-loaded with the action and resource, and every sentence adds useful information. 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?

Given the tool's simplicity (0 parameters, output schema present), the description satisfactorily covers what the tool does and what it returns. It mentions that the output includes descriptions, typical steps, and suggested operations, which is sufficiently complete for an agent to understand the tool's functionality.

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 schema description coverage is 100% (vacuously). The description does not need to clarify parameter meanings. However, it adds value by describing the return content, which helps the agent understand what to expect. A baseline of 4 is appropriate for a parameterless tool.

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

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

The description clearly states the tool's purpose: 'List all available derivation patterns.' It specifies the resource ('derivation patterns') and the verb ('list'), and the return value ('Descriptions, typical steps, and suggested operations') further clarifies the function. It distinguishes itself from sibling tools like 'derive' (which performs derivations) and 'list_assumptions' (which lists assumptions) by focusing on derivation patterns.

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 obtaining a list of patterns but does not provide explicit guidance on when to use this tool versus alternatives. It lacks statements about when not to use it or which other tools might be more appropriate for specific tasks. However, given the simplicity of a listing tool, the purpose itself offers adequate context for use.

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 fully disclose behavioral traits. It only states it is a lookup (read) operation without mentioning side effects, permissions, rate limits, or error handling. Minimal disclosure.

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

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

The description is short and structured with Args and Returns sections. However, the Returns section is redundant given the output schema. Could be more efficient but not overly verbose.

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

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

Given it's a simple lookup with 2 parameters and an output schema, the description covers basic purpose but lacks details on domain parameter behavior, error cases, and behavior if symbol is not found. Adequate but incomplete.

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

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

With 0% schema description coverage, the description should add meaning beyond parameter names. It merely lists name and domain without explaining valid values, format, or how domain affects results. Lacks examples or clarification.

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

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

The description clearly states it looks up the semantic meaning of a symbol, with a specific verb and resource. It distinguishes itself from sibling tools like register_symbol (create) and check_symbol_conflicts (check for conflicts).

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

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

The description implies usage for retrieving symbol meaning but provides no explicit guidance on when to use this tool versus alternatives like check_symbol_conflicts or list_domain_symbols. No when-not-to-use or alternative mentions.

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 burden. It explains the unified nature, stateless vs. session recording (session parameter), and lists operations and parameters. It does not mention destructive behavior (likely none) or rate limits, but provides good context on behavior for a math tool.

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

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

The description is long but well-structured with a summary, table of operations, parameter list, and examples. It is front-loaded and each section serves a purpose. Slightly verbose but justified due to the tool's complexity.

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

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

The description is very complete: covers purpose, all operations, parameter semantics, return format (Result dict with expression, latex, operation), and examples. With an output schema existing, it goes beyond minimum. It covers edge cases like integral bounds and assumptions.

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

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

Schema description coverage is 0%, so the description must compensate. It does so excellently: each parameter is explained in the Args section, and the operation table indicates which parameters are required for each operation. This adds significant meaning beyond the raw schema.

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

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

The description clearly states the tool's purpose: 'Run mathematical operations (unified Mathematica-style tool)'. It lists ~25 operations, making it distinct from sibling tools which are about sessions, assumptions, formulas, etc. The description explicitly says it is SymKit's core tool for mathematical tasks.

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 mathematical operations but does not explicitly guide when to use this tool versus siblings like 'derive' or other tools. It lacks statements about when not to use it or alternatives. Usage is implied by the broad scope.

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 burden. It states that registration happens in the current session and returns a result, but does not disclose whether it overwrites existing symbols, error handling, or idempotency.

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

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

The description is well-structured with sections for Args and Returns, uses an emoji for visual cue, and is concise with no unnecessary words.

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

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

The description covers the tool's purpose, parameters, and session context. It could mention whether duplicate registrations overwrite or error, but overall is adequate for an output schema that documents return values.

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

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

With 0% schema description coverage, the description provides detailed explanations for all 6 parameters, including examples for name (e.g., 'R', 'hbar') and meaning, adding significant value over the bare schema.

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

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

The description starts with a clear verb 'Register' and resource 'semantic meaning of a symbol in the current session', distinguishing it from sibling tools like lookup_symbol or assume.

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 that this tool is for registering a new symbol or meaning, but does not explicitly state when to use it vs. alternatives like lookup_symbol or when not to use it.

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

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

With no annotations, the description carries the full burden. It discloses that the session is saved to disk, but doesn't mention side effects, prerequisites, or whether the derivation can be resumed. The return value is vague ('Operation result').

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

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

Very concise (two lines plus return line). Could drop the 'Returns: Operation result' line since an output schema exists, but it's not overly 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 zero-parameter tool with no annotations, the description covers the core action. However, it lacks context about resumability compared to sibling session tools. Still fairly complete.

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

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

No parameters in the input schema, so schema coverage is 100%. The description adds no parameter info, but that is acceptable. Baseline 4 is appropriate.

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

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

The description clearly states 'Suspend the current derivation' with a specific verb and resource, and adds that the session is saved to disk. This distinguishes it from siblings like session_complete (end) or session_rollback (revert).

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 such as session_complete, session_resume, or session_rollback. The description implies pausing, but lacks explicit context.

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

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

With no annotations, the description must disclose behavioral traits. It only states the tool adds a note but does not explain side effects (e.g., whether it appends or overwrites), required session state, or authorization needs. The return type is vague ('Record result').

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

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

The description is concise, with the purpose front-loaded in the first line, followed by a standard Args/Returns format. Every sentence adds value, though the Returns section is minimal.

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 (3 parameters, no schema descriptions), the description is moderately complete. It explains the note type options and purpose but omits context like session prerequisites or whether the note is appended to a step or the session.

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

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

Schema description coverage is 0%, so the description must compensate. It lists possible values for 'note_type' and describes 'note' and 'related_variables' briefly, adding meaning beyond the schema. However, it lacks details on the format or constraints of 'related_variables'.

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

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

Description clearly states the tool adds a human knowledge note to the derivation, specifying it as a non-computational step. This distinct purpose differentiates it from sibling tools, which focus on computational steps, session management, or other actions.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'session_record_step' or other session tools. The description does not mention prerequisites like an active session or contrast with other note-related 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 must fully disclose behavior. It mentions auto-save behavior and the 'require_target_match' flag with warning, but does not clarify if the session ends, what gets saved, or whether further operations are allowed. The side effects of completing a derivation are not fully described.

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

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

The description is structured with a concise one-line purpose followed by an Args block. However, it is somewhat lengthy for a simple completion action. It could be more front-loaded and trimmed, but the structure is 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 8 parameters, no annotations, and an output schema (assumed rich), the description covers parameter purpose but lacks overall process context. It does not explain prerequisites, return value structure, or what 'completing the derivation' entails. The behavioral gaps leave the agent underinformed.

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

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

Schema description coverage is 0%, so the description must compensate. It provides a brief one-line explanation for each parameter (e.g., 'Formula description (physical/mathematical meaning)'). However, these explanations are shallow and do not include constraints, formats, or examples. Some parameters are just listed by name.

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 'Complete the derivation and auto-save' which clearly indicates the tool's purpose. It lists parameters and their meanings, distinguishing it from sibling tools like session_abort or session_rollback. However, it does not explicitly differentiate itself from similar session finalization tools.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., a session must be active) or contrast with siblings like session_abort or session_save (which doesn't exist as sibling). Usage context is only implied by the tool's name and parameter names.

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 details the tool's output (summary and structured metadata) and the aspects covered. Although no annotations exist, the description provides sufficient transparency for a read-only explanation tool. It does not mention side effects, which is appropriate as none are expected.

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

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

The description is concise: a brief introduction, a list of included items, and a clear Args section. Every sentence adds value, and the structure front-loads the purpose. 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?

Given the tool's straightforward purpose and the presence of an output schema, the description covers all necessary aspects: what it does, what information it includes, parameter details, and return type. No gaps are evident for expected 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?

The schema has 0% coverage (no property descriptions), so the description carries full burden. It explains both parameters: 'level' with values 'short', 'medium', 'detailed' and 'focus' with options 'assumptions', 'steps', 'result'. This adds significant meaning beyond the schema's default and type constraints.

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

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

The description clearly states the tool's action ('Explain the current derivation in natural language') and lists specific content covered (goal, formulas, operations, assumptions, result). It distinguishes itself from siblings like session_show and generate_derivation_report by focusing on natural-language explanation.

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 in any context where a human-readable summary of the derivation is needed. While it doesn't explicitly state when not to use or name alternatives, the purpose is clear enough for the agent to decide, especially given the context of sibling tools.

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

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

With no annotations provided, the description must disclose behavior but only states it returns steps with metadata. It doesn't mention ordering, state effects, or access requirements.

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

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

Two short sentences efficiently convey the purpose without unnecessary verbosity.

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

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

Given no parameters and the existence of an output schema, the description is adequate but lacks context on the execution environment (e.g., what constitutes a session). It could mention that steps are ordered or that metadata includes timestamps.

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?

No parameters exist, so the description doesn't need to add param details. The schema coverage is 100% by default, and a baseline of 4 is appropriate.

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

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

The description clearly states the action ('Return all recorded steps') and the scope ('in the current session'), distinguishing it from sibling tools like 'session_record_step' or 'session_explain'.

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 contrast with 'session_status' or 'session_show' which might provide similar information.

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

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

No annotations are provided, and the description does not disclose behavioral traits like read-only nature, output format, or ordering. It only states the basic action, leaving the agent with minimal behavioral understanding.

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?

Single sentence describing the tool's purpose with no extraneous information. Perfectly 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?

The description is minimal but acceptable given the tool's simplicity (no parameters, output schema exists). However, it lacks context about how the list is presented or how it fits into the overall workflow of derivation sessions.

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

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

The input schema has no parameters, so the description does not need to add parameter semantics. The zero-parameter case is handled implicitly, earning a baseline of 4.

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

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

The description clearly states the verb 'List' and the resource 'saved derivation sessions', which is specific and distinguishes from sibling tools like session_start or session_abort that operate on individual sessions.

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 such as session_status or list_assumptions. The description simply states the action without context for selection.

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

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

With no annotations, the description carries full burden. It clearly states it loads a formula into the session and explains arguments and return values. It does not discuss side effects, permissions, or error conditions, but overall behavior is well 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 structured with a summary, workflow, and Args/Returns sections. It is somewhat verbose but each sentence adds value. It could be slightly more concise without losing 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?

Given the tool's role in a multi-step workflow, the description provides a workflow and expected results. However, it does not explicitly mention prerequisites like needing an active session, which is assumed.

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

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

Schema description coverage is 0%, so the description must compensate. It provides clear explanations for all three parameters, including format hints and examples, adding significant meaning 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 starts with a clear verb and resource: 'Load a formula into the current session.' It distinguishes from sibling tools like formula_get and formula_add by providing a workflow that contextualizes 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?

The description gives a numbered workflow for correct usage, explaining when to use this tool in a sequence. However, it does not explicitly state when not to use it or provide exclusion criteria.

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

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

No annotations are provided, so the description carries full burden. It discloses that the 'operation' parameter is ignored and why, and that the expression is parsed through a unified parser. However, it lacks details on error handling 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 well-structured with a clear docstring format, but slightly verbose. Every sentence adds value, though it 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?

Given 6 parameters, 2 required, and an output schema, the description covers purpose, parameter meanings, and return. It lacks error handling but is otherwise complete.

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

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

Schema description coverage is 0%, so the description adds full meaning. Each parameter is described in the Args section, including the ignored behavior of 'operation' and the purpose of 'expression', 'description', 'notes', 'assumptions', and 'limitations'.

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 this tool is for manually recording a derivation step, e.g., a result computed outside the tool. It clearly contrasts with automatic derivation tools like 'derive' among 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 implies usage for manual results not automatically derived, but does not explicitly state when not to use or compare to alternatives like 'derive' or 'intent_execute'.

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 does not disclose preconditions (e.g., session must be suspended), side effects, permission requirements, or error conditions. The resume operation implies state change but is not elaborated.

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 (3 lines in a docstring format) and front-loaded with the purpose. However, the 'Returns' section is vague ('Session status'), which is acceptable since an output schema exists. Could be more structured for agent scanning.

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

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

Given the tool's role in session management and the existence of an output schema, the description is incomplete. It fails to mention expected session state (suspended vs active), error cases, or integration with other session tools. A user would need additional context.

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

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

Schema description coverage is 0%, and the description only repeats the parameter name ('session_id') with minimal context ('Session ID'). It does not explain how to obtain a session_id, format restrictions, or the meaning of the parameter 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 verb-resource combination 'Resume a suspended derivation session', which distinguishes it from sibling tools like session_start, session_abort, and session_status.

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., session_start for new sessions, session_abort for aborting). The description implies usage but does not specify prerequisites or exclusions.

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

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

Without annotations, the description discloses destructive behavior (deletes steps) and the ability to continue. However, it lacks warnings about irreversibility, prerequisites, or side effects on assumptions or other session state.

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

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

The description is concise: a clear purpose, a behavioral explanation, and parameter documentation. Every sentence adds value with 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 tool with one parameter and an existing output schema, the description covers the main functionality and edge case (0 clears all). Minor gaps: no mention of error handling for invalid step numbers or session state requirements.

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

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

Despite 0% schema description coverage, the description fully documents the single parameter 'to_step': it explains 1-based numbering and that 0 clears all. This adds essential meaning 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: rolling back to a specified step, keeping steps up to that step, deleting later steps. It distinguishes itself from sibling session tools by specifying the effect and allowing continued derivation.

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

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

The description implies usage when wanting to revert and diverge, but does not explicitly state when to use this tool over alternatives like session_abort or session_resume. No exclusions or conditions are provided.

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

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

No annotations are provided, so the description carries full burden. It notes that target_expression overrides automatically extracted targets but does not disclose side effects like session state changes, destructive potential, or required permissions. The behavioral info is minimal.

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

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

The description is concise, includes a clear Args and Returns section, and wastes no words. Every sentence adds value, and the structure is easy to scan.

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

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

The description covers the tool's purpose, parameters, and return value. However, it omits prerequisites (e.g., active session) and error conditions. Given the low complexity and presence of an output schema, it is adequate but has 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?

With 0% schema description coverage, the description compensates by explaining both parameters: goal as natural-language text and target_expression as an optional explicit expression with an example. This adds meaningful context beyond parameter names.

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

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

The description clearly states the tool sets a natural-language derivation goal for the current session, using specific verbs and resources. It distinguishes from sibling tools like session_start or session_resume by focusing on goal-setting, which is unique among 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 implies the tool is used to set a goal during a session but provides no explicit guidance on when to use it versus alternatives, nor does it mention when not to use it. The context is clear but lacks exclusions or alternatives.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It states the tool shows state and formula, and includes a warning about post-derivation usage. However, it does not mention side effects, permissions, or whether it is read-only. The description is adequate but not exhaustive.

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

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

The description is highly concise: three short sentences. The first states purpose, the second is a critical usage warning, the third describes the parameter. No wasted words, and the important instruction 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 the tool's simplicity (one optional boolean parameter) and the presence of an output schema, the description provides sufficient context. It specifies the tool shows current derivation state and formula, and includes a necessary usage warning. The sibling tool set is large, but the description distinguishes it adequately.

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

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

Schema description coverage is 0%, so the description must add meaning beyond the input schema. It explains the 'show_steps' parameter as 'Whether to show all step history', which adds context not present in the schema's title. The explanation is clear and helpful.

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 shows the current derivation state and formula, with a specific verb and resource. Among many session-related siblings, this distinguishes it by focusing on the current state and formula, not listing steps or status.

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

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

The description explicitly states it 'Must be called after each derivation operation to show the user the result!', providing clear guidance on when to use it. It does not explicitly list alternatives or when not to use, but the imperative is strong and contextually complete.

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 itself must disclose side effects and required context. It only states it starts a session and returns session info, but omits details like authentication needs, concurrency issues, or what happens if a session with the same name exists.

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

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

The description is concise and uses a clear Args/Returns structure. However, the Returns section could be more detailed.

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 6 parameters with zero schema descriptions and a complex tool ecosystem, the description fails to provide sufficient context. It does not explain how it relates to sibling session tools or what output schema details are important.

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

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

Schema description coverage is 0%, and the description merely lists parameter names without explaining their meaning, valid values, or how they affect behavior. For example, 'domain' defaults to 'general' but no clarification of allowed domains is provided.

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 'Start a new derivation session', specifying the verb and the resource. This distinguishes it from sibling session tools like session_list or session_resume.

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, nor does it explain prerequisites or when not to use it.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It only says 'Get' which implies no side effects, but does not explicitly state that it is read-only, safe, or requires no special permissions. The agent must infer this from the verb, which is adequate but not explicit.

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

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

The description is a single, concise sentence. Every word is necessary and adds value. No wasted 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 tool has no parameters and output schema exists (though not detailed here), the description is complete enough for a simple status retrieval. It lacks only deeper behavioral context, which is minor for this straightforward 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?

There are zero parameters, so the schema coverage is 100% (empty). The description does not need to add parameter details, and its brevity is appropriate. The baseline for 0 parameters is 4, and the description meets 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 'Get the current session status', specifying the verb (Get) and the resource (session status). It distinguishes from sibling tools like 'session_abort' or 'session_complete', which perform actions, by indicating a read-only observation.

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 that this tool is used to check the current session status, but it does not explicitly state when to use it versus alternatives like 'session_explain' or 'session_show'. No exclusions or alternative suggestions are provided.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It mentions the return type and purpose, but omits side effects, authentication needs, or prerequisites (e.g., a session goal must be set). Since this is a read-only suggestion tool, the lack of destructive behavior disclosure is acceptable, but other details are missing.

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

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

The description is very concise: one main sentence, plus Args and Returns sections with clear labeling. Every part serves a purpose, and key 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?

The tool is simple with one parameter and an output schema, so the description covers the basic purpose. However, it lacks context about prerequisites (e.g., an active session with a goal) and does not describe the rationale format in the output. Additional details 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?

The input schema has 0% description coverage, so the description compensates by explaining that top_k is the 'Maximum number of suggestions.' This adds basic meaning beyond the schema, but does not elaborate on the default value or valid range.

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

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

The description clearly states that the tool suggests formulas to help achieve the current session goal, with a specific verb 'suggest' and resource 'formulas'. It distinguishes from sibling tools like formula_search (which searches by query) and session_set_goal (which sets the goal).

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

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

The description implies usage when the agent needs suggestions related to the session goal, but it does not explicitly state when to use this tool versus alternatives like formula_search or tool_recommend. No exclusions or conditions are provided.

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

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

No annotations provided, so description carries burden. It describes the return summary (counts) but does not detail side effects, idempotency, or session requirements. Basic transparency but could be enhanced.

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 concise sentences: first states purpose, second describes output. No extraneous content, front-loaded, 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?

Given zero parameters and output schema present, description covers main purpose and return. Lacks note about session state requirements but is largely complete for a simple 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?

No parameters exist; baseline score is 4. The description adds value by explaining the return value structure, which compensates for the lack of 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 clearly states 'Verify the entire derivation chain in the current session' with a specific verb and resource. It distinguishes from sibling 'session_verify_step' which verifies a single 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?

Implies usage for full session verification but lacks explicit when-to-use, when-not, or alternatives. No mention of prerequisites or comparison with other 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 must fully disclose behavior. It only states 're-verify' and returns a 'verification result', but does not indicate side effects (e.g., whether it modifies state) or details about the result.

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

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

The description is concise with a clear first sentence stating the main action, followed by parameter details. No superfluous 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?

Given the existence of an output schema, the description provides adequate context for a simple verification action. However, it could mention prerequisites (active session) and that it is typically used after step modifications.

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

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

Schema coverage is 0%, so the description compensates well by explaining the parameter's purpose, that it is 1-based, and the default behavior. This adds significant meaning beyond the bare schema.

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

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

The description clearly states the verb 're-verify' and the resource 'a single step in the current session'. This distinguishes it from siblings like 'session_verify_session' which verifies the entire session.

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

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

The description explains the purpose but does not provide explicit guidance on when to use this tool versus alternatives. There are no 'when not to use' statements or references to other 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, and the description fails to disclose behavioral details such as what constitutes 'current scope', whether the tool has side effects, or the format of the returned assumptions. The description is minimal and leaves significant uncertainty.

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

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

The description is short with two sentences and no unnecessary words. However, the inclusion of a Returns section that mostly restates the first sentence is mildly redundant, preventing a perfect score.

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

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

Given the tool has no parameters, an output schema, and is relatively simple, the description is adequate but not thorough. It does not explain key concepts like 'current scope' or assumption representation, leaving some context for agent decision-making.

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 schema coverage is 100% (no params). The description adds value by stating the return object (assumptions in current MathContext), which goes beyond the empty schema. Baseline for 0 params is 4, and the description meets this baseline.

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

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

The description uses a specific verb 'Show' and resource 'symbolic assumptions' with scope 'current scope'. It clearly distinguishes from sibling tools like 'assume' (adds assumptions) and 'list_assumptions' (different listing context).

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 siblings like 'list_assumptions' or how assumptions are managed. The description does not provide context for appropriate 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, and the description does not disclose behavioral traits such as side effects or safety. It only mentions the return format, which is partially covered by the output schema.

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

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

The description is concise with two sentences, front-loading the core purpose with an emoji. It is clear but could be slightly more 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?

Given zero parameters and an output schema, the description is minimally adequate. However, it could mention that it provides a full catalog of available 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?

There are no parameters, so schema coverage is 100%. The description adds no parameter info, which is acceptable as none exist.

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

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

The description clearly states the tool lists SymKit tools organized by category, providing a specific verb and resource. It distinguishes from sibling tools like tool_recommend by specifying categorization, but does not explicitly contrast them.

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

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

No guidance on when to use this tool versus alternatives like tool_recommend or formula_categories. The description only states what it does, not the context of use.

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 explains that the tool returns a recommended tool with rationale and example, which covers its main behavior. No contradictions or hidden side effects are indicated.

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 plus structured Args/Returns. It is front-loaded with an emoji and every sentence adds value. 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 (two parameters, no nested objects) and the presence of an output schema, the description adequately covers what the tool does and returns. It is complete for its purpose.

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

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

Schema description coverage is 0%, so the description must compensate. The Args section adds meaning beyond the schema: 'Brief description of what you want to do' for task and 'Optional domain context' for domain. This is helpful but still brief, without examples or constraints.

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

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

The description clearly states 'Recommend the best tool(s) for a given task,' which is a specific verb+resource. The tool's meta-purpose distinguishes it from sibling tools that perform specific actions like assume, derive, or session management.

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 usage context is implied: it is meant for tasks where tool selection is needed. However, there is no explicit guidance on when to use this tool versus alternatives, nor are any exclusions or prerequisites mentioned.

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