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

With no annotations, the description carries the entire burden and meets it: it explains determinism ('without model calls'), result semantics (accept/reject/indeterminate plus digest, coverage, per-slice results), failure rules ('Missing required checks... cannot pass', 'known quality failure can reject even with incomplete evidence'), and the important exit_code vs MCP process status distinction. No behavioral trait is hidden.

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?

Six sentences, each adding a distinct fact: mode, inputs/outputs, hard failure rules, and the exit_code caveat. There is no filler, and the core purpose is front-loaded.

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

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

For a tool with no annotations and two non-trivial inputs, the description covers input semantics, decision logic, and process-vs-policy exit code behavior. It also has an output schema to further specify return values. Only minor gaps remain, such as exact accepted file path forms or explicit routing relative to sibling eval tools, but nothing that blocks correct invocation.

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

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

Schema coverage is 0%, so the description must add meaning, and it does: report_json_path is a full EvalReport JSON and policy_json_path is a 'multivon.policy/v1 JSON policy.' This is enough for an agent to know what each argument must reference, though it stops short of detailing path constraints or policy syntax.

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 first sentence names a specific verb ('Apply'), a specific resource ('versioned acceptance policy to saved evidence'), and a distinctive constraint ('without model calls'). It then states the outcome values and artifacts, clearly differentiating this offline policy gate from sibling model-based eval tools like eval_toxicity or eval_custom_rubric.

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

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

The phrase 'to saved evidence' and 'without model calls' indicates when this tool is appropriate: offline acceptance on an existing EvalReport JSON rather than generating a new evaluation. It does not explicitly name sibling alternatives or give negative routing guidance, so it misses full when-not-to-use clarity.

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

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

With no annotations, the description discloses the QAG grading method, return type (score, passed, reason), and the use of a judge model. It does not mention side effects or API dependencies, but for an eval tool this is acceptable.

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

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

The description is concise, with two focused paragraphs. The first paragraph states the purpose and method, the second details parameters and return value. No filler or redundant information.

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

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

Given the absence of an output schema, the description still provides the return format and explains the QAG method. It covers the essential aspects but could mention edge cases or error handling for 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?

Despite 0% schema description coverage, the description provides clear parameter semantics: expected_answer (ground-truth), actual_answer (LLM's answer), judge_model (provider:model). This compensates fully for the lack of schema descriptions.

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

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

The description clearly states the tool evaluates semantic equivalence of answers to ground truth using QAG, distinguishing it from strict string matching. Among sibling eval tools, this purpose is distinct and well-defined.

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

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

The description includes a clear usage guideline: 'Useful when string match is too strict (e.g. paraphrased correct answers).' It provides context but does not explicitly differentiate from other eval tools like eval_faithfulness or eval_hallucination.

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 usefully reveals that the ZIP is 'self-verifying, not tamper-proof', that the manifest hash should be anchored externally for tamper evidence, and that the returned manifest mirrors the one inside the ZIP. This goes beyond a simple 'build a zip' statement and helps the agent set correct expectations about the artifact's guarantees.

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

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

The description is well-structured with a front-loaded purpose statement, a concise composition list, a security caveat, and clearly separated Args/Returns sections. Every sentence adds information: what is combined, when it is suitable, what caveat applies, what each argument means, and what the return shape is. No wasted words.

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

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

The tool has an output schema and the description separately documents the return value, so return semantics are covered. It also explains the artifact contents, the tamper-evidence limitation, and per-argument provenance. It does not discuss error cases or whether an existing output file gets overwritten, but for a straightforward packaging tool the description is complete enough for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate, and it does. It explains run_json_path as output from 'pdfhell run --out', clarifies that cases_dir must be the same directory used by the run, and states where output_zip_path writes. The only weakness is that 'output_zip_path: Where to write the audit ZIP' is thin, but the overall parameter guidance is meaningful.

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

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

The description opens with a specific verb and resource: 'Build a self-verifying audit ZIP from a pdfhell run.' It clearly enumerates the ZIP contents (run JSON, case PDFs, answer keys, JUnit XML, SHA-256 manifest), which distinguishes it from the sibling eval_* tools that score or validate rather than package. An agent can immediately tell this is the packaging/audit artifact tool.

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

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

The description gives practical context: it is 'Suitable for attaching to a procurement diligence appendix' and explains when to anchor the manifest hash outside the ZIP ('when you need evidence against deliberate rewriting'). It does not name alternatives or explicitly say when not to use it, but the sibling tools are clearly different in function (metrics/scoring vs. artifact packaging), so this is sufficient guidance.

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

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

With no annotations provided, the description carries full burden. It explains the QAG-graded mechanism (five yes/no questions), score range (0.0-1.0), and return fields (score, passed, reason, threshold, evaluator). It also notes that input contextualizes whether disparate treatment is justified. Minor gaps: no discussion of failure modes or rate limits.

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

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

Description is well-structured: first sentence defines purpose, then mechanism, use cases, args, and returns. Every sentence adds value, and the most critical 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?

Given 3 parameters, no nested objects, and an output schema (whose structure is described), the description is thorough. It covers purpose, usage, mechanism, all parameters, and return format. No gaps for an evaluator tool.

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

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

Schema description coverage is 0%, so description must carry all parameter meaning. It does so comprehensively: explains 'input' as the prompt for context, 'output' as the LLM response, and 'judge_model' with a default provider:model. 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 identifies the tool's purpose with a specific verb ('Detect') and resource ('bias'), listing multiple bias types (gender, racial, political, etc.). It distinguishes from siblings like eval_toxicity by focusing on fairness audits rather than harmful content.

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

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

The description explicitly states when to use this tool: 'fairness audits on generated content, summarisation of user-submitted text, or hiring/lending-adjacent LLM pipelines.' It provides clear context but does not explicitly state when not to use it or list alternatives.

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

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

With no annotations provided, the description carries the full burden, and it does well: it discloses that files are loaded from disk, cases are paired by stable ID and case digest, McNemar's p-value is included only when pairing evidence supports it, and a large p-value does not establish equivalence. This prevents meaningful misinterpretation of statistical results and reveals the pairing behavior.

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

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

The description is long but well-structured: purpose, usage, args, and returns are clearly separated and front-loaded. The detailed Returns section earns its place because it documents the delta semantics and field shapes, though it is slightly more verbose than strictly necessary.

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

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

Given no annotations, minimal input schema, and complex return semantics, the description is complete. It covers input paths, pairing strategy, statistical caveats, return fields, and even pairing statistics like paired_count/added_count/removed_count so the agent can interpret drift between runs.

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

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

Schema description coverage is 0%, so the description must compensate, and it does. It defines baseline_json_path as the filesystem path to the baseline report JSON with an example, and new_json_path as the new/proposal report JSON to compare. This adds semantic meaning and role beyond the raw string type in the schema.

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

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

The opening sentence states a specific action and resource: 'Compare two multivon-eval report JSONs and return a structured diff.' This clearly distinguishes eval_compare_runs from the sibling eval_* tools, which perform their own single-report evaluations rather than pairwise comparison.

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

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

The description explicitly says when to use the tool: after a prompt/retrieval/model change when you want to know whether the new run improved on the baseline, case-by-case rather than only on aggregate. It does not explicitly name alternatives or state when-not-to-use, but the use-case guidance is clear enough to route an agent correctly.

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

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

Describes the judge process (each chunk up to 8, fraction relevant) and output format. With no annotations, the description adequately covers behavioral expectations.

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 clear sections (purpose, usage, args). Each sentence is informative, no fluff. Appropriate 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 output schema exists and describes return values, the description is complete: explains inputs, process, and return. 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?

Provides meaningful descriptions for all three parameters despite 0% schema coverage. Explains input, context formats, and judge_model default. Adds value 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 measures relevance of RAG context chunks to a question, defines high precision, and distinguishes it from sibling tools like eval_context_recall. The verb 'measure' and resource 'context precision' are specific.

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

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

Explicitly says to use for diagnosing retriever quality and gives examples of what low precision indicates. Does not explicitly mention when not to use or alternatives, but the context is clear.

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

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

No annotations exist, so the description carries full burden. It explains the judge's role: 'asks whether the expected answer could plausibly be reconstructed from the retrieved context alone.' It also defines 'high recall.' No destructive side effects are expected, and the behavioral disclosure 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 well-organized: a short summary, a clarification paragraph, an explicit usage line, and an Args section. It is efficient without being wordy, though it could be slightly more compact.

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 presence of an output schema, the description covers all essential aspects: purpose, usage context, parameter meanings, and the return structure (score, passed, reason, threshold, evaluator). This is fully sufficient for correct agent invocation.

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

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

Schema coverage is 0%, so the description must compensate. It lists all four parameters (input, context, expected_answer, judge_model) with brief but clear explanations. For example, it notes that context can be a list or single string. This adds 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 starts with a clear one-sentence purpose: 'Measure whether retrieved context contains enough information to answer.' It specifies the resource (retrieved context) and the action (measuring recall). The context of retriever vs. generator diagnosis distinguishes it from sibling tools like eval_context_precision or eval_faithfulness.

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 states when to use: 'when you have a labelled QA dataset and want to diagnose whether failures are retriever misses vs. generator errors.' It clearly sets the context but does not explicitly mention alternatives or when not to use it, leaving some room for improvement.

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 transparently explains the scoring mechanism (yes/no per criterion, fraction correct) and notes the use of a judge model. It does not disclose any destructive behavior (none expected) and adequately describes the evaluation process.

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 introduction, use-case paragraph, and enumerated arguments. It is appropriately sized for a tool with 6 parameters and a return value. A minor improvement could be trimming some redundant phrasing, but overall it is concise 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?

Given the tool has 6 parameters with no schema descriptions, and an output schema is present, the description covers all parameters and the return value (mentioning keys like score, passed, reason). It provides enough context for correct invocation, including examples and default values, making it complete for an evaluation tool.

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

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

Schema description coverage is 0%, so the description must fully explain parameters. It provides an Args section with clear definitions, including an example for the 'criteria' parameter that adds significant meaning beyond the schema's type-only specification. All six parameters are explained with defaults and types.

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

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

The description states 'Score an output against your own list of yes/no quality checks', clearly identifying the tool's purpose as a custom rubric evaluator. It distinguishes from sibling evaluation tools by noting it's for compliance-style rubrics, making its specific role clear.

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

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

The description explicitly says 'Best for compliance-style rubrics where each aspect should be auditable separately', providing clear context for when to use the tool. However, it does not mention when not to use it or explicitly contrast with sibling tools, but the guidance is sufficient.

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

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

With no annotations, the description carries the full burden. It discloses the tool's non-mutating nature by describing a return-only operation retturns a dict with six top-level keys and their semantics. It also adds behavioral context about avoiding hallucinated tool names. It doesn't mention potential side effects or rate limits, but for a catalog-retrieval tool the disclosed behavior is sufficient.

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

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

The description is well-structured and front-loaded with the core purpose. The return-value breakdown is detailed but not bloated. It could arguably be more concise, but every section earns its place by helping an agent understand what to expect.

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 discovery tool, the description is complete: it explains what the tool returns, how the agent should use it, and why it matters. The output schema exists, so the detailed return-value listing in the description is a helpful supplement, not a requirement. Nothing critical is missing.

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

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

The input schema has zero parameters, so there is no parameter semantics to document. The description appropriately focuses on the return value, which is what an agent needs to know. A baseline of 4 for zero-parameter tools is appropriate here.

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

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

The description states a specific verb ('Return') and resource ('full machine-readable capability catalog'). It clearly distinguishes this tool from the sibling evaluator tools by framing it as a discovery/capability-planning call, so an agent can tell it apart from eval_* and pdfhell_* tools.

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

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

The description explicitly says to use it 'as a first call at session start' so the agent can plan its evaluation strategy against available evaluators. It provides a clear context for use, though it does not explicitly state when not to use it or name an alternative discovery tool.

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

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

With no annotations, the description carries full transparency burden. It explains the vision judge evaluates three criteria, returns a structured response, and requires images per page. It lacks disclosure on performance implications or auth requirements, but for an evaluation tool, this is acceptable.

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

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

The description is concise and front-loaded with purpose, then uses Args/Returns structure to detail parameters and output. It is efficient with no wasted words, though slightly more structured formatting (e.g., line breaks) could improve readability.

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, 0% schema coverage, and an output schema, the description covers all aspects: required inputs, optional parameters, defaults, and return format. It misses edge cases like handling both image options, but overall sufficient for an 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?

Schema coverage is 0%, but the description fully documents all 6 parameters: input, output, images (paths/URLs/data URIs), images_base64 (alternative), mime_type (default png), judge_model (default and vision capability requirement). It explains constraints like using exactly one of images or images_base64, adding 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 checks document grounding for multi-page documents, specifying it answers three yes/no questions via a vision judge. This distinguishes it from sibling evaluation tools like eval_faithfulness or eval_vqa_faithfulness by being explicitly document-page-grounded.

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

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

The description provides clear usage guidelines: specify input and output, provide one image per page using exactly one of images or images_base64, and optionally set mime_type and judge_model. However, it does not explicitly contrast with alternative tools or state when not to use it.

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

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

With no annotations, the description carries the full burden. It explains the evaluation process: extracts factual claims, verifies each against context, and provides a score. It also specifies the default judge model and hints at its calibration. It lacks details on error handling or permissions but is fairly transparent.

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

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

The description is well-structured and concise: a one-sentence purpose, a brief explanation of the evaluator, a use-case line, then bullet-style parameter descriptions and a return format. Every sentence adds value with no redundancy.

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

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

The description covers the tool's purpose, usage context, behavioral details, parameter meanings, and return format (matching the output schema). For a tool with 4 parameters and no nested objects, this is comprehensive.

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

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

Schema coverage is 0%, so the description must compensate. It describes each parameter: 'input' as the user's question, 'context' as retrieved context, 'output' as LLM answer, and 'judge_model' with a default and hint. This adds meaning beyond the bare schema, though not extremely detailed.

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 evaluates whether an LLM output is grounded in retrieved context, using a specific evaluator (QAG-graded Faithfulness). It differentiates from sibling tools like eval_hallucination by focusing on factual claim verification against 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?

The description explicitly says when to use: 'when a RAG pipeline returned an answer and you want to check the LLM didn't invent facts.' It does not mention when not to use or name alternative tools, but the context of use is well-defined.

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

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

With no annotations provided, the description carries full burden. It discloses that the tool calls an external generator, requires an API key, and returns a specific data structure. It does not mention potential latency or costs, but is transparent about the dependency on an underlying judge model and the generation process.

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

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

The description is front-loaded with a clear one-sentence summary. It then follows a structured docstring format with Args and Returns sections. While somewhat lengthy, each sentence adds value; minor redundancy could be trimmed 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 complexity (4 parameters, no schema descriptions, no annotations), the description covers purpose, parameters with defaults, output structure, and prerequisites (API key). It does not mention error handling or edge cases (e.g., API failure), but for a generation tool, the provided information is sufficient for an agent to use it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It provides a detailed 'Args' section explaining each parameter: 'from_text' (source text), 'n' (number of cases, default 10), 'task' (QA, summarization, hallucination with explanations), and 'judge_model' (provider:model string with default). This fully adds 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 verb 'Generate' and the resource 'synthetic eval cases' from a source text. It distinguishes itself from sibling evaluation metrics by focusing on generation rather than evaluation, and provides specifics like producing 'input', 'expected_output', and 'context' for each case.

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 mentions eliminating the cold-start problem when building an eval suite, implying use when starting from scratch. It also notes the requirement of a provider API key. However, it does not explicitly state when not to use or provide alternatives among siblings, though the sibling tools are mostly evaluation metrics, making this tool's purpose distinct.

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 two independent runs are averaged by default to mitigate position/framing bias, and describes the return format. It does not discuss authorization, rate limits, or destructive effects, but those are not critical for a scoring tool.

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

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

The description is well-structured with a summary line, usage guidance, parameter list, and return format. It is front-loaded with the core purpose. Every sentence adds value, and there is no redundancy.

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

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

Given 6 parameters, no annotations, and an output schema (described in text), the description is comprehensive. It covers purpose, behavior, parameters, return format, and sibling comparison. No gaps are evident for the tool's complexity.

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

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

Schema description coverage is 0% (no parameter descriptions in schema), but the description's Args section provides detailed semantics for each parameter: input, output, criteria, name, runs, judge_model. It explains defaults and purpose, fully compensating for the schema's lack.

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 performs 'G-Eval style holistic scoring against a plain-English criterion', using specific verbs and resources. It distinguishes from sibling eval_custom_rubric by noting that tool is better for 'criteria with multiple discrete aspects'.

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 recommends this tool for 'fuzzy or holistic qualities' and explicitly names eval_custom_rubric as an alternative. It also explains the dual-run averaging for variance reduction. However, it lacks explicit when-not-to-use guidance beyond the alternative mention.

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 describes return format but does not disclose if it makes external API calls via judge_model or any side effects, permissions, or rate limits.

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?

Front-loaded purpose, concise arguments and returns sections. Could be slightly tighter if output schema were present, 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?

Covers purpose, parameters, and return structure, but lacks usage guidance and behavioral context. Given medium complexity and available output schema, gaps remain.

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?

Adds clear explanations for each parameter beyond the schema (e.g., 'The LLM output to check', 'Provider:model for the QAG judge'), compensating for zero schema description coverage.

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

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

Clearly states it detects fabricated information not in context. Differentiates from siblings by naming hallucination detection but does not explicitly compare to eval_faithfulness or others.

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 score interpretation but lacks guidance on when to use this tool versus alternatives like eval_faithfulness, and no exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It discloses supported frameworks, expected input structure (trace_json must include input and steps), and the return shape (keys like input, expected_output, agent_trace). It does not cover error handling or edge cases, but for a conversion tool, the disclosure 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 well-structured with a clear summary, usage guidance, framework details, and structured Args/Returns sections. It is informative without being overly verbose, though it could be slightly shorter while retaining 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 complexity (multiple frameworks, conversion task) and minimal schema, the description is complete. It explains the output shape (return dict keys) so that the agent knows how to use the result with other eval_* tools. The presence of an output schema in signals does not detract from the description's 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 schema has 0% description coverage, so the description must compensate. It does so thoroughly: explains that trace_json must include 'input' and 'steps' (or 'new_items' for openai_agents), and lists the three valid framework values. 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 states exactly what the tool does: 'Convert a JSON agent trace into a JSON-friendly EvalCase payload.' It is specific about the verb ('Convert') and the resource ('agent trace into EvalCase payload'), and it clearly distinguishes itself from sibling eval_* tools by focusing on trace ingestion rather than evaluation.

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

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

The description explicitly says when to use: 'Use this when your agent has just finished a trajectory at runtime and you want to score that trajectory immediately.' It provides context for usage but does not explicitly state when not to use it or compare to alternatives. The guidance is clear but could be more comprehensive with exclusions.

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

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

With no annotations provided, the description shoulders the full transparency burden, and it succeeds. It discloses local execution, score semantics, reason-field content, redaction behavior, jurisdiction handling, and custom pattern support. It also documents the exact return shape, so an agent can predict the tool's behavior accurately.

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 detailed but well-organized: a one-sentence purpose, a concise behavioral note, then Args/Returns sections. Every sentence adds useful information, and the most important decision-relevant details are front-loaded.

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

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

The description is fully complete for this tool's complexity. It covers all four parameters, the output schema fields, scoring behavior, privacy characteristics, and extension points. Even though an output schema exists, the description adds decision-relevant context such as the threshold/evaluator fields and jurisdiction semantics.

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

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

Schema description coverage is 0%, so the description must compensate, and it does extensively. It explains what 'output' is scanned, enumerates every jurisdiction value, gives a concrete custom_patterns example, and clarifies the effect of redact. This adds substantial meaning beyond the bare schema properties.

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

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

The description opens with a specific verb and resource: 'Detect personally-identifiable information (PII) in an LLM output.' It also clarifies the local-first scope and defines the 1.0/0.0 scoring meaning, making it clearly distinct from sibling eval tools such as eval_toxicity or eval_schema_compliance.

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

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

The description gives clear context for when to use the tool: whenever PII detection in LLM output is needed, with a strong signal that it is suitable for privacy-sensitive cases because it is local-first and makes zero API calls. It does not explicitly name alternatives or state when-not-to-use it, so it stops short of a 5.

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

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

With no annotations provided, the description carries the full burden. It discloses the QAG method and the return structure, but does not mention side effects, permissions, rate limits, or determinism. The behavioral disclosure is adequate but not comprehensive.

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

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

The description is short, front-loaded with the purpose, and structured with Args and Returns sections. Every sentence is necessary and no extraneous information is present.

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

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

Given the tool has 3 parameters and an output schema described in the returns, the description covers the main points: method, parameters, and return values. However, it misses explaining the threshold default and configuration, and lacks guidance on when to use this tool versus siblings. Still, it is largely 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 coverage is 0%, so the description must add parameter meaning. It clearly explains input as 'The user's question', output as 'The LLM's response', and judge_model with format 'Provider:model'. This adds value beyond the schema's titles and types. A slight deduction for lacking constraints on judge_model 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 the tool checks if an LLM output addresses the user's question, using a QAG-graded method. This is a specific verb+resource, and the method detail (generates yes/no questions) distinguishes it from sibling evaluators like eval_answer_accuracy or eval_faithfulness.

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 relevance checking, but does not explicitly provide when-to-use or when-not-to-use guidance relative to sibling tools. No alternatives or exclusions are mentioned, which is a gap given the presence of many similar eval_* tools.

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

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

No annotations are provided, so the description carries full burden. It thoroughly explains behavior: tolerant parsing (strips markdown fences), per-field validation errors, strict mode effect, and the exact return format. No contradictions.

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

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

The description is well-structured and front-loaded with the purpose. It is slightly lengthy due to parameter and return details, but each sentence adds value. 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 complexity (3 parameters, output schema exists), the description is complete. It explains the return format, error handling, and parameter semantics. No gaps remain for the agent to guess.

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

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

Schema description coverage is 0%, but the description compensates fully with detailed parameter explanations: 'output' as LLM-generated text, 'schema' with a concrete JSON Schema example, and 'strict' with its boolean effect. This adds 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 clearly states the tool's purpose: 'Validate that an LLM output conforms to a JSON Schema.' It differentiates from sibling eval tools by focusing on schema compliance, and mentions internal details that help the agent understand its 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?

Explicit usage guidance is provided: 'For Pydantic-model validation or more advanced setups... use the multivon-eval SDK directly.' This tells the agent when not to use this tool, and the description explains the tool's capabilities (tolerant parsing, per-field errors) that help decide when 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 provided, the description carries full behavioral disclosure responsibility, and it does very well. It explicitly states 'Pure deterministic — no LLM judge needed', explains exact argument comparison, describes order-sensitive behavior, optional unexpected-call penalization, the empty-list assertion, and the return/error contract.

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

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

The description is front-loaded with the core purpose and then organized into mode bullets, Args, and Returns. Despite covering eight parameters and two modes, it contains no filler and each sentence adds necessary information.

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

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

For a complex evaluation tool with zero annotations and zero schema descriptions, the description is remarkably complete. It covers both modes, the relationship to eval_ingest_trace, special cases like empty expected_tool_calls, default-order behavior, penalization semantics, return schema, and the error condition for invalid argument combinations.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: every parameter is named and given operational meaning. Expected/actual arguments are tied to single-call mode, expected_tool_calls and agent_trace to trace mode, and require_order/penalize_unexpected to boolean behavioral switches.

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

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

The description opens with a specific verb and resource: 'Evaluate whether an agent called the expected tool or tool sequence.' It clearly distinguishes this as an evaluation tool for tool-call accuracy, not a generic evaluator or a tool being evaluated. The mention of two modes further pins down what the tool does.

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

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

The description gives clear context for when each mode applies: single-call mode for comparing one expected/actual pair, trace mode for consuming the canonical agent_trace from eval_ingest_trace. It does not explicitly name alternatives or state 'use this instead of X', but the mode breakdown and deterministic no-LLM-judge note give sufficient decision guidance.

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

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

No annotations are provided, so the description carries full burden. It describes the scoring logic (four yes/no questions, fraction), the returned output schema, and that it evaluates LLM output. It does not mention any destructive side effects, which is appropriate for a read-only evaluation 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 concisely structured with a clear one-line purpose, followed by grading details, usage guidance, and parameter explanations. Every sentence adds necessary information without redundancy.

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

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

Given the tool's simplicity (2 parameters, output schema provided), the description covers all necessary aspects: purpose, scoring method, usage context, parameter details, and return value structure. No gaps remain.

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 adds full meaning: 'output' is defined as 'The LLM-generated text to evaluate' and 'judge_model' is explained with examples and default. This compensates entirely for the schema's lack of descriptions.

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

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

The description clearly states the tool detects harmful content in LLM output, with a specific verb 'detect' and resource. It explains the QAG-grading mechanism, distinguishing it from sibling eval tools like eval_bias or eval_hallucination.

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

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

The description explicitly says to use for guardrails, chatbot turns, or user-facing LLM output where harmful content is a risk. It provides clear context but does not mention when not to use or compare directly to alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the internal process (claim extraction, verification), the scoring logic, and the return format including score, passed, reason, threshold, and evaluator. It also details judge_model options and cautions about Haiku quality. It doesn't disclose edge cases (e.g., unreadable images) but covers the core behavior thoroughly.

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

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

The description is well-organized into sections (purpose, usage, image input, args, returns) and front-loads the core purpose and method. Though moderately long, every sentence adds necessary information for a tool with six parameters. There is no redundancy or filler.

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

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

Given the tool's complexity (6 params, no annotations, output schema present), the description is complete. It covers all parameters, defaults, alternatives, return format, and usage guidance. It even notes the threshold field in the output. An agent has everything needed to call it correctly.

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

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

Schema description coverage is 0%, so the description fully compensates. The Args section provides detailed explanations for all six parameters, including input/output roles, image input alternatives (path/URL/data URI vs. base64), mime_type defaults and common values, and judge_model defaults and alternatives. This goes well beyond the bare schema definitions.

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

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

The description opens with a precise statement of what the tool does: 'Check whether an LLM answer about an image is grounded in what's visible.' It then details the method (extract up to 3 factual claims, verify each against the image, score = fraction accurate). This clearly distinguishes it from text-only siblings like eval_faithfulness and eval_hallucination.

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

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

The description explicitly states when to use it: 'Use this for visual QA, image captioning, chart/diagram reading, and any LLM output that purports to describe an image.' This gives clear positive use cases, but it does not explicitly mention alternatives or when not to use it. It could be improved by naming text-only counterparts (e.g., eval_faithfulness) as not applicable.

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 discloses output structure (dict with case JSON and optional PDF bytes) and behavioral guarantee (same seed yields identical output). No destructive side effects are implied, which is appropriate for a generative tool.

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

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

The description is well-structured with a summary line, usage context, and an Args/Returns list. Every sentence adds value, though it is slightly verbose. It front-loads the primary purpose.

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

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

Given the presence of an output schema and the tool's simplicity, the description covers essential aspects: output structure, parameter semantics, and usage context. It is sufficient for an agent to invoke the tool correctly.

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

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

With 0% schema description coverage, the description fully explains all three parameters: trap (family name, examples, source of truth), seed (integer, determinism), and return_pdf_bytes (default behavior and purpose). This goes well beyond the bare schema.

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

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

The description clearly states the tool's purpose: 'Generate one adversarial PDF + its answer key.' It uses a specific verb-resource pair and distinguishes itself from siblings like eval_discover and pdfhell_run by noting that eval_discover lists trap families.

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 this tool ('to inspect what a specific trap looks like before deciding to evaluate against it') and provides guidance on obtaining trap family names via eval_discover. It does not explicitly exclude scenarios but gives clear context for typical usage.

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

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

With no annotations provided, the description fully carries the burden. It discloses that it runs a benchmark, calls external APIs using environment variables (with keys like ANTHROPIC_API_KEY), and that keys are not logged. It also describes the return value structure. This provides good behavioral insight, though it does not explicitly state non-destructive or rate-limit behaviors.

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' and 'Returns' sections, making it easy to parse. It uses bullet points for suite options and includes example formats for model. Every sentence provides useful information; there is no fluff. It is appropriately sized for the tool's complexity.

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

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

Given that an output schema exists, the description needs not detail return values fully. However, it does summarize the return dict and notes that suite version/hash are included. It covers the tool's purpose, all parameters with defaults, and additional context about environment variables. The description is complete for this tool's context.

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

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

The input schema has 0% description coverage, so the description must compensate. It does so excellently: model format with examples, suite options with case counts and cost estimates, and workers with default. This adds significant meaning beyond the raw schema types. Every parameter is explained with concrete details.

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 'Run the pdfhell adversarial-PDF benchmark against a vision model,' which clearly states the verb (run) and resource (adversarial-PDF benchmark). This distinguishes it from sibling eval_* tools and pdfhell_make, all of which have different purposes. The purpose is specific and immediately understandable.

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

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

While the description explains what the tool does and details the parameters, it does not explicitly guide when to use this tool versus alternatives like pdfhell_make or other eval tools. It implies usage when running a pdfhell benchmark, but no explicit when-to-use/when-not-to-use guidance is provided. The lack of differentiation from siblings limits the score.

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