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

Annotations are all false/absent, so the description carries the full burden. It discloses that activation sends notifications and permanently prevents adding documents or signatories, which is critical behavioral context beyond the annotations. It also implies the mutation side effects (irreversible lock).

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

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

The description is dense but not bloated; it front-loads the core action and then adds necessary workflow context. Every sentence contributes value, though it could be slightly more concise given the density.

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

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

The description covers the full operational context: required prior steps, the effect of activation (notifications sent, lock on additions), and a recommended alternative (signature_request_full). With an output schema present, not explaining return values is acceptable, and the description is complete for an agent to decide and invoke correctly.

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

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

Schema coverage is 100% for the single parameter (signatureRequestId), and the schema already explains it is a mandatory UUID obtained from create_signature_request. The description repeats this requirement but does not add new parameter-level semantics beyond the schema, so it meets the baseline 3.

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

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

The description clearly states the action ('Activates a signature request, sending signing notifications to every added signatory') and the resource. It distinguishes from siblings by noting the post-activation lock (no more documents or signatories can be added) and by referencing alternative tools for adding roles before activation.

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 when-to-use guidance: prerequisites (create_signature_request → signatureRequestId, documents with bytes uploaded, signatories per document) and alternatives (add_validator_to_signatory / add_observer_to_document before activating; prefer signature_request_full for a new request). This clearly differentiates when to use this tool vs 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?

The description discloses the 2-step upload behavior, the need to PUT file bytes to the returned upload URL, the hash prerequisite, and the meaning of each signatureType enum value. Annotations are mostly false booleans, so the description carries the behavioral burden and does so well, though it does not detail side effects beyond the workflow.

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

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

The description is front-loaded with the main purpose and workflow, and every section serves a purpose. The signature type explanations are verbose but valuable for correct enum selection, so the length is justified despite being dense.

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

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

The description covers the core workflow, prerequisites, and sibling-tool routing, but the tool has 15 parameters and a complex nested schema. Omitting evidenceId and most optional parameters makes it incomplete for fully correct invocation, even though the output schema likely covers 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?

Schema description coverage is only 13%, so the description must compensate. It adds real meaning for signatureRequestId, hash, and signatureType, but ignores many optional parameters and never mentions evidenceId, which the schema itself labels MANDATORY. It partially compensates but leaves notable gaps.

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

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

The description states a specific verb and resource ('Adds a document to a signature request') and clearly frames it as the first step of a 2-step upload workflow. It distinguishes itself from related sibling tools like create_signature_request, add_signatory_to_document, and signature_request_full by naming them in 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?

It gives explicit prerequisites (create_signature_request → signatureRequestId, precomputed SHA-256 hash), sequencing (add signatories before activating), and an alternative path (signature_request_full composite tool). It also states 'Use once per document', which is actionable usage 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?

Annotations already indicate this is a non-read-only, non-idempotent, non-destructive write operation, and the description's 'Adds' is consistent with that. It adds useful behavioral context beyond the annotations by explaining the observer's read-only visibility, the timing constraint relative to activation, and the required prior calls. There is no contradiction between the description and annotations.

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

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

The description is two tightly packed sentences with no filler. It front-loads the core action and role definition, then gives the critical timing constraint and prerequisites. Every sentence earns its place.

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

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

Given the output schema exists, return-value documentation is not needed. The description covers what the tool does, the observer's role, when to call it, and the required prior calls. It is sufficient for an agent to select and invoke the tool correctly, though it could have added more detail about what happens if an observer is added twice or whether an invitation email is sent.

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 only 40%, so the description carries partial burden. It does add meaning for signatureRequestId and documentId by naming the prerequisite calls that produce them, though the schema descriptions already say 'Obtain from create_signature_request' and 'Obtain from add_document_to_signature_request.' It does not meaningfully explain name, email, or surnames beyond the schema, and it does not explicitly map all four required fields to the observer's identity.

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 specific verb and resource: 'Adds an observer to a signature request's document.' It then defines the observer role as read-only visibility without signing, which clearly distinguishes this from sibling tools like add_signatory_to_document and add_validator_to_signatory. The purpose is unambiguous and scoped.

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 this must happen: 'Add observers BEFORE activate_signature_request.' It also names the required prerequisite chain: create_signature_request → signatureRequestId and add_document_to_signature_request → documentId. It does not explicitly name alternative tools or say 'use this instead of X,' but the 'without signing' phrasing and sequencing provide clear operational 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?

Annotations already signal a non-read-only, non-idempotent mutation. The description adds valuable lifecycle context beyond annotations: the strict ordering dependency and the irreversible activation boundary. This helps an agent understand the operational impact of calling this tool at the wrong time.

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

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

Three dense sentences with no filler. The action is stated first, followed by usage frequency, prerequisites, and the critical activation constraint. Every sentence contributes essential 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?

The description covers the core workflow well: what the tool does, how to use it, its prerequisites, and the key lifecycle restriction. Optional parameters are not elaborated, but the presence of an output schema and the focus on the required flow keep this reasonably complete 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 only 22%, so the description carries meaningful burden. It clarifies that name and email identify the signatory and that signatureRequestId/documentId come from prior API calls. However, optional parameters like phone, sequence, coordinates, and uniqueValidator are left unexplained, leaving gaps for non-basic usage.

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 and resource: 'Adds a signatory (by name + email) to a document within a signature request.' It clearly distinguishes this from sibling tools like add_validator_to_signatory and add_observer_to_document by emphasizing the signatory role and the document 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?

It gives explicit when-to-use guidance: 'Use once per person who needs to sign that specific document.' It also states prerequisites (create_signature_request and add_document_to_signature_request) and a clear when-not: signatories cannot be added after activation.

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

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

Annotations already carry readOnly=false, idempotent=false, and destructive=false, so the description only needs to add operational context. It does so by explaining the validator's approval role)Skip and the ordering requirement before activation, plus the inline composite alternative.

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 four terse sentences with the core behavior front-loaded. Each sentence adds distinct information: role, timing, prerequisite chain, and composite alternative. There is no filler or restatement of the schema.

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

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

Given that an output schema exists and annotations carry the mutation/idempotency hints, the description provides the essential workflow context: prerequisites, sequencing, and the inline alternative. It does not discuss duplicate-validator behavior or post-activation restrictions, but those are not central to selecting and invoking this tool correctly.

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

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

Schema coverage is only 33%, and the description substantially compensates for the two ID parameters by naming their exact source tools. However, name, email, phone, and surnames receive no additional meaning beyond their schema labels, so the description does not fully bridge the coverage gap.

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 verb and resource: 'Adds a validator to a document's signatory' and clearly defines what a validator does. The role definition and the activation sequencing separate it from sibling tools like add_signatory_to_document and add_observer_to_document.

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

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

The description gives explicit timing guidance ('BEFORE activate_signature_request'), a prerequisite chain for obtaining documentId and signatoryId, and notes that signature_request_full accepts validators inline as an alternative. It does not fully explain when to prefer the composite inline path over this tool, but the relevant workflow context is present.

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 annotations only set readOnlyHint=false, indicating mutation. The description builds on that by clarifying it creates a container, returning an id, and stating there are no prerequisites. It does not conflict with annotations and adds practical behavioral context (the returned id and its reuse). However, it does not disclose any side effects like notifications or whether partial creation is possible, which would have boosted the score further.

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

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

The description is two sentences: the first delivers the core purpose and ordering, the second provides a concrete example and the follow-up action. It is front-loaded with the essential information and contains zero filler. Every sentence earns its place, making it easy for an agent to parse quickly.

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

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

The description is adequate for the minimal use case: it tells the agent to create with name and createdBy, get an id, and proceed to add documents. However, given the tool has 12 parameters with nested objects and enums, the description does not guide the agent on optional fields that may be critical for specific flows (e.g., webhookUris, closeConfig). Since an output schema is indicated, return values are covered, but the parameter usage beyond the basics remains undocumented, leaving a moderate 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?

With a schema description coverage of 0%, the description was expected to compensate for the 12 parameters. It only illustrates 'name' and 'createdBy' via an example, and does not explain any of the other parameter semantics (e.g., closeConfig, provider, signatureRequestBody). The example implicitly shows the required fields but does not clarify their meaning beyond what the schema names suggest. This is insufficient compensation for parameters that have complex nested structures and enums.

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

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

The description states a clear verb and resource: 'Creates a new signature request' and identifies it as 'the top-level container for documents and signatories in a signing flow.' It explicitly differentiates it from the sibling add_document_to_signature_request by saying 'Use this first, before add_document_to_signature_request,' leaving no ambiguity about what this tool does.

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

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

The description provides explicit usage guidance: 'Use this first, before add_document_to_signature_request' and 'No prerequisites.' It also instructs the agent to use the returned id as signatureRequestId in subsequent calls, giving a clear sequencing and onward pointer that is highly actionable.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that 'no credentials needed' and that it serves as a discovery/guidance tool, which is useful contextual information beyond the structured fields.

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

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

The description is two sentences, front-loaded with the core action ('Returns an overview'), and every phrase earns its place. It covers contents, usage, and access requirements without waste.

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

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

With no params and no output schema, the description is the sole source of guidance. It fully explains what the tool returns (managers and key tools), when to use it (first if unsure), the key decision guidance (composite vs. atomic), and access requirements (no credentials). This is complete for a help tool.

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

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

The tool has zero parameters, which is the baseline for a score of 4. The description does not need to explain parameter semantics because the schema has no properties, and the 100% schema coverage means there is nothing to add.

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

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

The description clearly states the tool 'Returns an overview of EAD Factory's managers' with specific verbs and resources, listing the manager types (Evidence, Signature, Notification, Chat) and the guidance it provides. This distinguishes it from the many sibling tools that perform domain actions rather than providing help.

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 advises 'Call this first if you're unsure which tool to use' and mentions guidance on composite vs. atomic tool selection (e.g., evidence_create_sealed). This gives clear when-to-use direction and differentiates its purpose from the operational 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?

Beyond annotations (which are all false), the description discloses that the API does not auto-assign an id, requiring the caller to generate a UUID v4, and that 'title' is used instead of 'name.' It also reveals the relationship between the created case file id and subsequent evidence_group_create calls, adding meaningful 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 three concise sentences that lead with the core purpose, then provide usage ordering and the unique id rule, ending with a practical example. 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?

Given the tool's role as the top-level entry point, the description covers the essential context: what it creates, when to use it, its key parameter quirks, and how it connects to the next logical tool (evidence_group_create). The presence of an output schema means return value details are handled elsewhere.

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 compensates by fully explaining the critical 'id' parameter (caller-generated) and the 'title' parameter (replaces name), and provides an example. Other optional parameters (code, owner, category, metadata, description) are not detailed, but their purposes are inferable from their names and the overall context.

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 'Creates a new case file — the top-level container for evidence groups, evidence, and reports,' clearly stating the verb and resource. It also distinguishes this from sibling tools by noting it is the entry point to the Evidence-manager toolset and highlighting the caller-supplied id quirk.

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

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

Explicitly instructs 'Use this first, before any other Evidence-manager tool' and states 'No prerequisites.' The description also clarifies when not to expect typical create behavior (id is caller-supplied, no name field) and gives a concrete example that ties into evidence_group_create.

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

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

Annotations already mark destructiveHint=true, but the description adds 'not reversible' and a confirmation workflow, reinforcing the severity beyond what annotations convey. No contradiction with idempotentHint or readOnlyHint.

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

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

Two sentences, front-loaded with the destructive nature and purpose. Every word adds value, and the alternative is mentioned succinctly.

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 bulk delete with only two params and no output schema, the description covers the critical destructive warning, the need to confirm IDs, and the alternative tool. It does not explicitly mention the requestId requirement, but that is fully described in the schema, so nothing essential is missing.

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

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

Schema coverage is 50% (only requestId has a description). The tool description mentions 'caseFileIds' but doesn't elaborate on the ids array structure beyond the schema's UUID format, and it never mentions the requestId parameter. The schema already compensates well for requestId, so the description adds little beyond the vague reference to caseFileIds.

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 ('deletes'), resource ('case files'), and scope ('SEVERAL ... in one call'). It also distinguishes itself from the sibling evidence_case_file_status_update by explicitly framing the alternative when only ending work is needed.

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

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

It gives clear when-to-use guidance: confirm IDs first via evidence_case_file_search, and prefer status update instead if the goal is merely to end work. This is explicit and actionable.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful context about the dependency on evidence_case_file_create for the caseFileId and the purpose of checking status before subsequent operations, which goes beyond the annotations.

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

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

The description is two sentences, front-loaded with the action, and every sentence adds value: the first defines the function, the second provides use cases and a prerequisite. No filler 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?

With a single parameter, full schema coverage, output schema present, and safety annotations already provided, this description is complete. It explains when to use the tool and the prerequisite relationship, making it sufficient for an agent to invoke correctly.

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

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

The input schema covers the single parameter fully with a detailed description including the UUID format and source from evidence_case_file_create. The tool description adds little beyond restating 'by id', so the schema does the heavy lifting, meriting the baseline score of 3.

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

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

The description clearly states 'Retrieves a case file's details by id', specifying the verb, resource, and identifier. This distinguishes it from sibling tools like evidence_case_file_search (searching) and evidence_case_file_create (creation).

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 'to confirm a case file exists, or to check its status before creating evidence groups or reports under it', providing clear use cases. It does not explicitly name alternative tools for scenarios like searching without an ID, but the context is sufficient.

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

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

Annotations already indicate this is a write operation (readOnlyHint:false) and non-destructive. The description adds useful context about the dependency on evidence_case_file_create and the traceability purpose. It does not disclose behavior like idempotency, overwrite semantics, or failure modes, but annotations lower the bar for this dimension.

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

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

The description is two concise sentences plus a short prerequisite line. It is front-loaded with the action and resource, then provides usage context, with 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?

There is no output schema and the parameter descriptions are sparse, but the description provides workflow context and a clear prerequisite. It lacks detail on itemType/itemValue semantics and what happens after the relationship is assigned, leaving gaps for a mutation tool with three required parameters.

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 only 33% (caseFileId is described), and the description compensates only partially. It explains where to get caseFileId and hints that itemValue relates to a matter/client/system record, but it does not clarify the itemType enum (CHAT_CONVERSATION) or the expected format of itemValue. With low schema coverage, more parameter guidance is needed.

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

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

The description clearly states 'Assigns a relationship on a case file' and explains it links the case file to an external/related entity reference for traceability. This specific verb+resource+scope distinguishes it from sibling case_file tools like evidence_case_file_update or evidence_case_file_get.

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

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

The description gives explicit usage context: 'Use after creating the case file when your workflow tracks which matter, client, or system record it belongs to.' It also names the prerequisite step (evidence_case_file_create → caseFileId). However, it does not mention when not to use the tool or provide alternatives, so it falls 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?

The annotations only indicate the tool is not read-only, not idempotent, and not destructive. The description adds useful behavioral context: it produces a signed/certified document and returns a reportId that must be passed to download endpoints. It does not fully disclose side effects or repeatability, but it adds meaning beyond the annotations.

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

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

The description is compact and front-loaded: the action, the output, the follow-up tools, and the prerequisites are all covered in two sentences with no filler. Every sentence earns its place.

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

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

The surrounding workflow is well described, including prerequisites and downstream URL-getter tools. However, the description does not explain the meaning of several required inputs or resolve the apparent tension between the required reportId input and the 'Returns a reportId' statement. Given the high parameter count and low schema coverage, this is a clear gap.

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

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

Schema description coverage is only 22%, so the description needed to compensate, but it only clarifies caseFileId's origin and the reportId's downstream use. Required parameters like template and languageCode are not explained, and the nested data object is entirely left to the schema. This is a significant gap for a 9-parameter tool.

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

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

The description uses a specific verb ('Generates') and clearly identifies the resource as the SIGNED evidentiary report of a case file. It also distinguishes the tool from its download siblings and from the preview tool by stating exactly what this step produces.

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

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

It explicitly states the prerequisite chain: evidence_case_file_create must provide caseFileId, and preview must happen first via evidence_case_file_report_preview. It also names the follow-up download tools, so an agent knows exactly when to call this tool and what to do afterward.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds useful context beyond annotations: it mentions the signed document nature, the required prior generation step, and the scope of what is returned. No contradiction with annotations.

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 tightly packed sentences: the first states the purpose, the second covers prerequisites and alternative. No redundant words, front-loaded with the key action.

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

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

Given the simple nature (2 required params, read-only, output schema present), the description covers all essential context: what it retrieves, the required sequence, and the alternative for broader needs. No gaps for the agent to correctly select and invoke the tool.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds meaning by specifying that reportId is obtained from the generate step, complementing the schema's existing origin note for caseFileId. This provides the causal chain for parameter 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's function: retrieving a download URL for a signed PDF document of a case-file report. It distinguishes from the sibling tool evidence_case_file_report_zip_url_get by specifying it returns only the signed PDF, not the full evidence package.

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 the prerequisite chain: evidence_case_file_report_generate must be called to obtain the reportId. Also provides a clear alternative (use evidence_case_file_report_zip_url_get for the full package), guiding when not to use this tool.

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

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

Annotations provide readOnlyHint=false, idempotentHint=false, destructiveHint=false, but the description adds key behavioral context: the output is UNSIGNED, it's a preview, and it requires sealed evidence groups. It also implies the tool does not produce the final signed report. This adds value beyond annotations, though it doesn't detail side effects or rate limits. No contradiction with annotations.

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

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

The description is two sentences, front-loads the core purpose and the unsigned nature, and includes the prerequisite chain compactly. Every sentence earns its place with no fluff.

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

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

The tool has 6 parameters, nested objects, and an output schema. The description explains the tool's role in the workflow (preview before signed generation) and the prerequisite. It doesn't explain the return value, but an output schema exists, so that's not required. It also doesn't detail what 'sealed evidence groups' means, but the schema and sibling names provide context. Overall, it's complete enough for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is only 17%, so the description must compensate. The description mentions caseFileId and the prerequisite chain, and the schema itself documents caseFileId as MANDATORY. However, the description does not explain the meaning of template, languageCode, data, metadata, or additionalData beyond what the schema provides. The schema has detailed structure for data.groups, but the description adds little semantic meaning for the other parameters. Baseline 3 is appropriate because the schema does provide some structure, but the description doesn't fully compensate for the low coverage.

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

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

The description clearly states the tool generates an UNSIGNED preview of a case file's evidentiary report, with a specific verb ('Generates'), resource ('case file's evidentiary report'), and purpose ('check its content before producing the signed version'). It also explicitly names the sibling tool evidence_case_file_report_generate for the signed version, distinguishing it from alternatives.

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

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

The description explicitly states when to use this tool: to check content before producing the signed version, and names the alternative (evidence_case_file_report_generate) for the signed version. It also provides a prerequisite chain: evidence_case_file_create → caseFileId, with sealed evidence groups inside. This is clear usage 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?

Annotations are minimal (no readOnly, no destructive hint), but they don't contradict. The description clarifies it only updates metadata and does not re-generate content, which is useful. However, it does not disclose potential side effects, idempotency, or what happens to existing metadata fields, leaving behavioral uncertainty for a mutation tool.

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

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

The description is a single, concise paragraph that front-loads the purpose and includes the prerequisite and limitation in one go. No wasted words; every sentence adds value.

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

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

For a metadata update tool with 3 parameters, the description covers required inputs and the main limitation. However, it doesn't explain the 'deletionDate' parameter (what it does, how to use it), and the lack of output schema means no guidance on return values. Given the tool's moderate complexity, this is acceptable but not 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 67%, and the schema already documents reportId and caseFileId as MANDATORY. The description adds that these come from generate, but doesn't explain the 'deletionDate' parameter, which is the third parameter. This leaves a gap for the optional parameter.

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

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

The description clearly states it updates metadata of an existing case-file report, with a specific verb and resource. It does not explicitly distinguish from sibling tools like evidence_case_file_report_preview or evidence_case_file_report_pdf_url_get, but the update action is unique enough in 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?

It explicitly notes a prerequisite (evidence_case_file_report_generate → reportId and caseFileId) and states when not to use it (does not re-generate content; generate a new report for updated evidence). This provides clear context for using the tool, though it does not mention alternatives in the sibling set.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds the dependency on prior generation and the packaged contents, providing useful context beyond the annotations.

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 the purpose, second states the prerequisite. No redundant or vague wording.

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

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

For a simple read-only URL getter with output schema present, the description covers purpose, prerequisite, and the package contents. Sibling differentiation is clear enough given the tool name and description.

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

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

Schema coverage is 100%, and both parameters already have descriptive text (mandatory UUIDs, source for caseFileId). The description only references the same parameters without adding additional semantics.

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 retrieves a download URL for a complete ZIP package of a case-file report, specifying the contents (signed PDF plus evidence files and verification material). This distinguishes it from sibling tools like evidence_case_file_report_pdf_url_get.

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 the prerequisite call (evidence_case_file_report_generate) and required identifiers (reportId, caseFileId). However, it doesn't explicitly contrast with alternatives like pdf_url_get or evidence_report_zip_url_get, though the 'complete ZIP' phrasing implies when to use this tool.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description itself does not disclose any behavioral nuances beyond what the generic search verbs imply — no note on result scope, matching semantics, pagination behavior, or performance. It adds little value beyond the 'when-to-use' aspect and hence is lower than what would be expected to reach a 3.

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

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

Two sentences: the first provides the action and a list, the second provides concrete usage context. No filler words, the information is front-loaded and each sentence has a 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?

The core decision when to use the tool is explained and an output schema exists, so the return type doesn't need to be restated. Yet the filter parameter is a nested object with many fields, and the description only gives a partial and slightly inaccurate list of filters. Thus, while sufficient to understand the tool's role, it falls short of fully guiding an agent through the filter structure.

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?

All schema descriptions are absent, so the description must compensate, but it only mentions 'name, status, dates, pagination'. It omits code, owner, category, metadata, and sort, and crucially calls 'title' as 'name'. This leads to potential confusion in an agent that relies on the description, so the compensation is partial and somewhat misaligned.

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

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

The description states the verb 'Searches' and the resource 'case files', and its use case of finding a caseFileId when absent. It also explicitly contrasts with evidence_case_file_create, which separates it from creation. However, it uses 'name' where the schema defines 'title', causing slight ambiguity in field recognition.

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

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

The description clearly states when to use it: to find a caseFileId when you don't have it, or to list before creating with evidence_case_file_create. This provides useful context and names an alternative. It doesn't explicitly mention when to switch to evidence_case_file_get once the ID is known, so it is strong but not exhaustive.

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

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

Annotations already indicate a non-read-only mutation. The description adds a key behavioral consequence: CLOSE means no longer accepting new evidence groups. It does not contradict annotations and enriches the state-change semantics.

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

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

Two sentences, front-loaded with the core action, then usage guidance and prerequisite. Every sentence contributes meaningful information with no filler.

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

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

For a simple two-parameter status update with annotations and no output schema, the description covers purpose, usage, key behavioral effect, and parameter provenance. It is fully sufficient for an agent to select and invoke 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 documents caseFileId with a description and source, but status is a bare enum. The description explains the meaning of each status value ('CLOSE' vs 'OPEN'), adding semantic value that the schema lacks.

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 ('Changes') and resource ('case file's lifecycle status'), with explicit values (OPEN/CLOSE). This distinguishes it from sibling tools like evidence_case_file_update, which handle general updates.

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

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

Provides explicit when-to-use context ('Use CLOSE when work is finished... reopen with OPEN') and a prerequisite chain ('Requires: evidence_case_file_create or evidence_case_file_search → caseFileId'). This clearly guides an agent on invocation and 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?

The description adds context beyond the neutral annotations by specifying it operates on 'editable metadata' (excluding lifecycle state) and targets a single file. It does not mention partial-update semantics or return values, but the key behavioral boundaries are clear.

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

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

Two concise sentences: the first states the core action with examples, the second covers prerequisite and alternative. Every word earns its place, and the most important information is front-loaded.

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

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

Given the lack of output schema and presence of a nested metadata object, the description could explain whether omitted fields are preserved and which fields are considered editable. It provides a solid scope but leaves some behavioral details unstated.

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

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

Schema description coverage is low (14%), and the description's examples ('name, description') are partially misleading because 'name' is not a property (likely 'title'), and it does not explain the metadata object or other fields. The description adds minimal value over the schema.

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

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

The description clearly states it updates a single case file's editable metadata with examples, and explicitly differentiates from sibling tools like evidence_case_file_update_bulk (single vs bulk) and evidence_case_file_status_update (lifecycle vs metadata).

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

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

It explicitly provides a prerequisite (obtain caseFileId from evidence_case_file_create or evidence_case_file_search) and directs the agent to use evidence_case_file_status_update for lifecycle changes, offering a clear alternative and when-not-to-use context.

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

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

Annotations already indicate readOnlyHint=false, destructiveHint=false, and idempotentHint=false. The description adds that it updates 'editable metadata' and operates on multiple files, but does not disclose failure semantics, partial success behavior, or any side effects beyond what annotations imply.

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

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

The description is three short sentences, front-loaded with the primary purpose. Every sentence provides useful information without redundancy, making it easy to parse quickly.

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

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

The tool has no output schema and the description gives some usage context, but it lacks explanation of the relationship between ids and patch, and does not address bulk operation caveats like atomicity or partial failures. Given the complexity of a bulk update, the description is incomplete.

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

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

The schema has 0% description coverage, and the description does not compensate. It claims 'each entry carries its own caseFileId and changes,' which does not match the actual schema structure of separate 'ids' and 'patch' arrays, potentially misleading the agent about how parameters relate.

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 updates editable metadata of several case files in one call, using a specific verb and resource. It also distinguishes itself from evidence_case_file_update, which is for a single case file, making the purpose unmistakable.

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

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

The description explicitly instructs to prefer evidence_case_file_update for single case files, providing an alternative. It also tells the user they need caseFileIds and points to evidence_case_file_search to find them, giving clear when-to-use and prerequisite 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 present, the description carries the full burden and does so thoroughly. It discloses that the tool bounded-polls until CLOSED, that task-aware MCP clients get an asynchronous Task while others get a synchronous result, and that the upstream emits no transition events, which explains the polling behavior. It also specifies the success return payload: group id, final CLOSED status, and each evidence's id + sha256.

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

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

The description is dense but every sentence earns its place: overview, behavioral note, prerequisite, alternative-path parameter, file contract, return shape, and explicit alternative-selection guidance. The most important information is front-loaded in the first sentence.

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

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

For a complex composite tool with no output schema, the description covers the essential operational context: prerequisites, alternate mode of reuse, async vs sync delivery, return shape, and when to prefer sibling tools. Combined with the fully described input schema, an agent has enough to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful semantic context beyond the schema. It clarifies that groupName and groupType apply only when creating a new group, that evidenceGroupId targets an existing OPEN group, and that the file field follows a shared FileInput contract rather than a bespoke file field.

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 composite verb chain — 'Creates (or reuses) an evidence group, registers and uploads one or more files as evidence, then seals (closes) the group' — and clearly separates this one-call flagship flow from the atomic sibling tools. It also explicitly names evidence_group_create, evidence_group_evidence_register, and evidence_group_close, making the tool's role unambiguous.

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

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

The description gives explicit when-to-use guidance: use this tool for the full flow, and use the atomic sibling tools instead when you need to inspect or react to each intermediate step. It also states the prerequisite (case_file_create -> caseFileId) and explains when to supply evidenceGroupId for an existing OPEN group versus omitting it to create a new one.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, and the description reinforces 'Permanently deletes' and 'Destructive.' It adds behavioral context about sealed content and the 'no group path needed' distinction, going beyond annotations.

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

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

Two sentences, front-loaded with purpose, then caution and prerequisite. Every sentence earns its place with no wasted words.

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

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

For a simple one-parameter delete tool with strong annotations, the description covers purpose, usage constraints, prerequisites, and destructive nature. No output schema exists but none is needed for a delete operation; the description is fully adequate.

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

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

Schema coverage is 100% with a detailed description of the evidenceId parameter, so the baseline is 3. The description repeats how to obtain the ID and adds 'no group path needed' context, but does not add substantial new parameter semantics.

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+resource+scope: 'Permanently deletes one evidence by evidenceId (no group path needed).' It distinguishes from siblings like evidence_group_evidence_delete by explicitly noting no group path is required, and from bulk operations by saying 'one evidence.'

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?

Clear when-to-use and when-not-to-use guidance: 'sealed content should not be deleted — use only for drafts or mis-registered evidence.' Also specifies prerequisite: 'Requires: evidence_group_evidence_register or generate_evidence → evidenceId.'

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description only needs to supplement. It adds the temporary-URL nature and equivalence to the sibling endpoint, which is useful, though it omits expiration details.

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 contain the action, scope, prerequisite, and alternative without filler. The sentence structure front-loads the core purpose and places supporting details afterward.

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

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

For a single-parameter tool with strong annotations and no output schema, the description covers purpose, prerequisites, and sibling differentiation. A minor gap is the lack of URL expiration or response format, but this is not essential for this 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?

The schema fully documents evidenceId, and the description adds practical context: it is the sole identifier required (no group path) and can be obtained from generate_evidence or evidence_group_evidence_register. This complements the schema rather than repeating 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 opens with a specific verb-resource pair: 'Creates a temporary download URL for an evidence's stored file.' It also clearly distinguishes itself from the sibling evidence_group_evidence_download_url_create by noting 'no group path needed' and 'same bytes.'

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

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

It explicitly states when to use this tool ('when you only hold the evidenceId'), names the alternative for the group-path case, and provides the prerequisite evidence-generation flow. This gives the agent clear decision boundaries.

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 annotation indicates non-read-only (readOnlyHint=false) but no destructive flag. The description goes beyond annotations by revealing the async state machine (OPEN → CLOSING → CLOSED), the need to poll evidence_group_get, and the irreversible consequence ('no more evidence can be added'). This adds valuable behavioral context not present in annotations.

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 information-dense but every sentence earns its place: main action, precondition, required inputs, async behavior, and alternative tool. It is well-structured and front-loaded with the core purpose.

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

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

Given the complexity of the tool (state transitions, prerequisites, async polling), the description covers all essential aspects: what happens, when to use, what to do after invocation (poll until CLOSED), and a simpler alternative. The presence of an output schema reduces the need to explain return values, so this is 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 50% (only caseFileId and evidenceGroupId have descriptions). The description adds meaning for evidencesCount as 'the current evidencesCount' and explains the provenance chain for the IDs. However, collectMetadata is not mentioned at all, leaving its semantics unexplained. Overall, the description partially compensates for the schema gaps.

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: 'Seals (closes) an evidence group, triggering qualified timestamping — after this, no more evidence can be added.' This is a specific verb+resource and distinguishes from siblings like evidence_group_discard or evidence_group_update by emphasizing the sealing aspect.

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 conditions are given: 'Use only after every evidence registered in the group has had its file bytes uploaded to the presigned URL from evidence_group_evidence_register.' It also names an alternative ('Prefer the evidence_create_sealed composite tool') and lists required dependencies, providing clear when-to-use and when-to-avoid 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?

Annotations carry little weight (all false), so the description must disclose behavior. It does so by noting the caller-supplied id (non-idempotent), the returned status 'OPEN', and the sequencing with other tools. However, it omits details like error conditions or side effects, but the provided operational flow is valuable.

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 somewhat long but each sentence adds value, including a concrete example and workflow steps. It is front-loaded with the core purpose and then provides operational details, though it could be slightly more concise without losing meaning.

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

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

Given the tool's complexity and the presence of an output schema (not shown but indicated), the description gives sufficient context: creation context, prerequisite, example, and next steps. It doesn't fully explain all return values, but the essential lifecycle is clear.

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

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

Schema coverage is only 13%, and the description compensates by explaining the required parameters: id ('generate a fresh UUID v4 yourself'), caseFileId (from evidence_case_file_create), and type (example 'FILE'). It doesn't explain optional parameters like name or metadata, but the mandatory ones are clarified.

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 'Creates an evidence group inside a case file,' using a specific verb and resource. It distinguishes from siblings by referencing the legacy generate_evidence tool and mentioning evidence_group_evidence_register and evidence_group_close for the 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?

Explicitly states when to use: 'Use when starting a new batch of related evidence (e.g. all files for one incident).' It also gives prerequisites (evidence_case_file_create → caseFileId) and a sequential workflow with evidence_group_evidence_register and evidence_group_close, effectively explaining alternatives and 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?

Annotations already declare readOnlyHint=false and destructiveHint=true, so the description builds on that with a specific warning that permanently deleting sealed groups is unsafe due to issued reports. It adds a concrete restriction beyond the annotations though it does not elaborate on idempotency (already hinted) or partial-failure behavior. The warning about sealed reports is a meaningful extra 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 three purposeful sentences: it states the action, delivers a warning, and lists required inputs with a discovery pointer. It has no filler, front-loads the key distinction, and uses succinct imperative guidance ('never delete sealed groups') 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?

The description gives sufficient context for a destructive bulk operation: it covers purpose, scoping, warnings, and how to locate inputs. However, it omits the mandatory `requestId` from its explicit required-input list; though the schema defines it, an agent relying on the description could miss a required parameter. The absent output schema is not a problem for a delete operation, but the missing requirement in the prose is a small 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?

With 67% schema description coverage, the description still maps 'evidenceGroupIds' to the `ids` parameter and explicitly references the search tool to find them. It also restates that caseFileId is required, but it fails to mention the required 'requestId' though that is fully defined in the schema. The description adds value for the otherwise undocumented `ids` parameter but doesn't fully cover all required parameters.

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

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

The description states a specific verb ('deletes') plus the resource ('SEVERAL evidence groups of one case file') in a single call. It distinguishes itself from the sibling evidence_group_discard (single group) and evidence_group_delete_bulk by explicitly contrasting with the singular alternative, so an agent can select it without opening schemas.

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

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

It explicitly says 'prefer evidence_group_discard for a single group' and 'never delete sealed groups that back issued reports,' which provides clear when-to-use and when-not-to-use direction. It also tells the agent to use evidence_group_search to find the group IDs, closing the loop on how to prepare inputs.

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

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

Annotations already mark destructiveHint=true, and the description reinforces this with 'Destructive' and 'deletes... registered evidences'. It adds useful context beyond annotations by specifying that only OPEN groups are discardable and that CLOSED/sealed groups are immutable, which helps the agent understand state constraints.

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

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

The description is two sentences, front-loaded with the action and use-case, followed by a concise destructive warning and prerequisite note. Every sentence contributes 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?

For a simple two-parameter destructive tool with full schema descriptions and strong annotations, the description covers the action, state constraints, destructive consequence, and dependency chain. It does not describe return/error behavior, but no output schema exists and delete operations commonly return a simple success status, so this is an acceptable omission.

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

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

Schema coverage is 100% with both parameters fully described, including their UUID format and provenance ('Obtain from evidence_case_file_create' and 'Obtain from evidence_group_create'). The description's 'Requires' line adds a compact dependency hint but does not meaningfully extend the schema's parameter semantics.

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 ('Discards (deletes)') naming the resource ('OPEN evidence group and its registered evidences') and the intended use ('abandon a group you no longer intend to seal'). It also distinguishes the operation from handling sealed/CLOSED groups, which separates it from related evidence_group 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?

It clearly states when to use the tool ('use to abandon a group you no longer intend to seal') and when not to ('sealed (CLOSED) groups are immutable evidence and should not be discarded'). It also gives a prerequisite chain ('Requires: caseFileId + evidence_group_create → evidenceGroupId'), but does not explicitly name alternatives like evidence_group_delete_bulk.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, but the description adds 'Permanently deletes' (reinforcing irreversibility) and the critical constraint that sealed groups are immutable. This goes beyond the structured annotations by explaining the operational precondition (group must be OPEN). It does not contradict any annotations.

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

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

The description is two sentences with no redundant words. The core purpose is front-loaded, the open-group constraint follows logically, and the parameter chain is stated compactly. Every sentence earns its place.

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

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

For a delete operation with no output schema, the description covers the action, the prerequisite (open group), and the parameter dependency chain. Combined with 100% schema coverage and strong annotations (destructive, idempotent), it is largely complete. A minor ambiguity remains about whether it deletes the evidence record itself or just the group membership, but the tool naming and sibling context mitigate this.

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

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

Schema coverage is 100%, and each parameter has a description with provenance (e.g., 'Obtain from evidence_group_evidence_register'). The description's 'Requires: caseFileId + evidenceGroupId + evidence_group_evidence_register → evidenceId' is a concise restatement of the relationships already detailed in the schema, adding no additional semantic meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the action: 'Permanently deletes one evidence from an evidence group.' It uses a specific verb ('deletes') and resource ('one evidence from an evidence group'), which distinguishes it from siblings like evidence_group_delete_bulk (deletes entire group) and evidence_delete (deletes evidence globally). The scope is explicit.

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

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

The description provides clear context: 'Only makes sense while the group is still OPEN (sealed groups are immutable).' This tells the agent when to use the tool and when not to. It also mentions the required parameter chain (caseFileId + evidenceGroupId + evidence_group_evidence_register → evidenceId), which implies the evidence must have been registered via that flow. However, it does not explicitly name alternative tools or contrast with them.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds 'temporary' (expiring URL) and 'after upload' workflow, but does not detail expiration duration or response format. This is useful but not rich behavioral 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 two sentences, front-loaded with the core action, and every sentence earns its place. The requirement chain is compact and useful without being 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 the tool's simplicity, 3 UUID parameters, and good annotations, the description is adequate. It states the output (download URL), the use case, and prerequisites. It lacks expiration details or error conditions, but these are not essential for basic invocation with strong schema support.

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

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

Schema coverage is 100% and each parameter includes provenance guidance (e.g., 'Obtain from evidence_case_file_create'). The description restates the required chain but adds no new parameter semantics beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states it creates a temporary download URL for an evidence file in a group, distinguishing it from similar tools like evidence_download_url_create. The verb and resource are specific, and the parenthetical '(INTERNAL custody)' adds differentiation.

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

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

The description gives clear context: use it to retrieve original bytes after upload, and it lists the required ID chain (caseFileId + evidenceGroupId + evidence_group_evidence_register → evidenceId). It does not explicitly name alternatives or exclusions, but the context implies when to use it versus non-group downloads.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds a general sense of non-mutating behavior (via 'Gets') and lists the fields returned, but does not disclose error conditions, pagination, or other behavioral nuances. This is adequate but not rich.

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

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

The description is two short sentences. The first sentence front-loads the main purpose; the second provides terse, high-value prerequisite guidance. There is no redundant filler.

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

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

For a straightforward get tool with three required UUIDs and an output schema present, the description supplies all necessary context: what it returns, the group scope, and how to obtain each ID. The presence of an output schema means return-value details do not need to be in the description. It is complete.

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

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

The input schema covers 100% of parameters, each with a description and a source tool. The description's 'Requires' chain partially echoes the schema, but adds no new semantic meaning about parameter values or format. Baseline of 3 is appropriate given high schema coverage.

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

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

The description explicitly states the action ('Gets'), the resource ('one evidence's details'), and the scope ('inside a specific evidence group'). It also lists the specific data returned (metadata, hash, custody, upload state), which clearly distinguishes it from sibling tools like evidence_group_get or get_evidence.

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 a clear prerequisite chain ('Requires: evidence_case_file_create → caseFileId, evidence_group_create → evidenceGroupId, evidence_group_evidence_register → evidenceId'), telling the agent which upstream tools to call to obtain each required parameter. 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?

Annotations only indicate non-read-only and non-destructive; the description adds substantial behavioral context: the two-step register-then-PUT workflow, the returned upload URL, the close-group constraint, and the custody/testimony semantics. This meaningfully shapes how an agent should sequence and invoke the 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?

Front-loaded with the core purpose, then prerequisites, then workflow warning, then enum definitions. It is dense and somewhat long, but every sentence carries useful information and the structure is logical.

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 16-param, 8-required, multi-step tool, it covers the workflow, prerequisites, and key domain concepts, and the output schema handles return values. But the 'Requires' list omits evidenceId even though it is mandatory, and the link between requiredTestimonyProviders and the testimony provider families is not made explicit, leaving gaps for a fully correct call.

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

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

Schema description coverage is only 19%, so the description must compensate. It explains custodyType (INTERNAL vs EXTERNAL), testimony families (TSP vs DLT), and the hash prerequisite. However, it leaves several mandatory params like evidenceId, capturedAt, and requiredTestimonyProviders largely to inference, so the compensation is only partial.

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

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

States a specific verb and resource: 'Register a new evidence in a group', and frames it as the first step of a 2-step upload. It also distinguishes itself from the evidence_create_sealed composite and from later upload/close steps, so an agent can tell it apart from 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?

Explicitly says 'Use for each file you want to add to an OPEN evidence group', names the evidence_create_sealed alternative, and warns not to call evidence_group_close until bytes are uploaded. It lacks an explicit when-not-to-use list, but the OPEN qualifier and named alternative provide clear routing.

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

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

Annotations do not provide meaningful safety hints (readOnlyHint=false, destructiveHint=false, idempotentHint=false). The description adds context beyond annotations by framing this as step 2 of a flow, requiring PUT to the returned URL, and noting the URL may expire ('fresh' URL, 'expired or was lost'). It also discloses that evidence_create_sealed covers this automatically. No contradiction with annotations.

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

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

Three sentences, each earning its place: purpose, when-to-use, requirements, and alternative. The information is front-loaded and free of fluff. The description is highly compact while packing flow context, usage guidance, and a cross-reference to an alternative tool.

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

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

No output schema exists, but the description implicitly states the return value by saying 'PUT the file bytes to the returned URL.' It also covers the flow context, prerequisites, and alternative. It does not go into URL expiry details or invalidation of previous URLs, but 'fresh' implies this. For a focused URL-generation tool, this is sufficiently complete.

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

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

Schema description coverage is 75%, with the three UUID parameters having rich descriptions ('Obtain from...'). The description repeats these three as 'Requires: caseFileId + evidenceGroupId + evidenceId' but omits the nested requestModel object and its required fileName. Since the schema itself already documents the UUIDs well, the description adds little new semantic value and leaves the requestModel parameter unexplained.

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

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

The description uses a specific verb and resource: 'Creates a fresh presigned upload URL for an ALREADY-REGISTERED evidence in a group'. It clearly differentiates from siblings by specifying step 2 of the register-then-upload flow, noting that evidence_create_sealed automates the whole flow. This leaves no ambiguity about 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?

It explicitly states when to use: 'Use when the URL from evidence_group_evidence_register expired or was lost.' It also mentions an alternative: 'evidence_create_sealed does all of this automatically,' which effectively tells the agent when not to use this tool and choose a higher-level wrapper instead.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable context by enumerating the returned elements (status, seal, upload states) and the dependency chain, which is useful beyond the annotations. It doesn't contradict annotations.

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 front-load the primary action and then provide usage guidance and prerequisites. Every word adds value, with no fluff or repetition of schema details.

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

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

For a simple 2-parameter read operation with a rich output schema and complete annotations, the description covers the purpose, content, and usage timing. It also gives the lifecycle context (before/after close) and requires dependencies, making it fully self-contained for the tool's complexity.

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

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

Schema description coverage is 100% with each parameter already describing its purpose and origin. The description's 'Requires' line is mostly redundant with the schema's 'Obtain from' instructions, providing only marginal added meaning about the relationship between the two 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 the tool 'Gets one evidence group's details' and specifies the exact content (status, seal information, evidences with upload states). The verb 'Gets' plus the resource scope ('one evidence group') clearly distinguishes this from sibling tools like evidence_group_search or evidence_group_evidence_get.

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

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

It explicitly provides two concrete use cases: verifying all files uploaded before evidence_group_close, and checking the seal after closing. It also gives a prerequisite chain ('Requires: caseFileId + evidence_group_create → evidenceGroupId') that clarifies the expected workflow.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so safety is covered. The description adds behavioral context beyond annotations by specifying cross-case-file scope, optional filters, and the fact that results are sufficient for finding an ID but not full detail. No contradictions exist.

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

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

Two sentences with no filler: the first states the core function and filters, the second gives the primary use case and routes to the sibling for full detail. Everything earns its place.

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

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

The description covers the main purpose and key filters, and the output schema presumably documents return values. However, it does not clarify that the required 'filter' object can be empty to list all groups, nor does it explain how 'pending sealing' maps to a specific status value. These are meaningful gaps for a complex nested filter parameter.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'status, dates, pagination,' which maps to some filter properties, but it does not explain id, code, name, type, createdBy, caseFileId, metadata, or sort. The schema itself is self-descriptive, but the description only partially bridges the coverage gap.

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

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

The description states a specific action ('Searches evidence groups across case files') with a clear resource and scope. It also differentiates from the sibling evidence_group_get by noting that full detail should use that tool, so an agent can distinguish between 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?

It explicitly says when to use this tool: 'to find an evidenceGroupId or list groups pending sealing.' It also names the alternative for full detail, evidence_group_get, making the selection criteria unambiguous.

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

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

The description adds critical behavioral context beyond annotations: the OPEN-only constraint and immutability of sealed groups. It also clarifies the ID acquisition flow. Annotations only provide readOnlyHint=false and destructiveHint=false, which align with the description (updating metadata is non-destructive but write-oriented). No contradiction detected.

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

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

The description is two sentences, front-loaded with the core action and then constraints. Every clause adds value: the action, the OPEN-state caveat, and the prerequisite chain. There is no redundant fluff or repetition of schema information.

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

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

For a tool with 7 parameters, a nested object, and an output schema, the description covers the essential purpose and key constraints but leaves ambiguity about which fields are editable and how metadata should be structured. The output schema exists, but since it's not shown, the description should better clarify parameter roles, especially for optional fields like createdBy and metadata. Overall, it's adequate for selection but not for full invocation without additional inference.

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

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

Schema description coverage is only 29%, so the description must compensate, but it only mentions 'e.g. name, description' and doesn't explain the semantics of code, metadata, or createdBy. It also fails to clarify whether createdBy is actually editable, given the description says 'editable metadata' while schema lists createdBy as a property. The required IDs are described in the schema, but the description adds little beyond a dependency hint.

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

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

The description clearly states the action: 'Updates an evidence group's editable metadata' with specific examples (name, description). It identifies the resource (evidence group) and scope (editable metadata), distinguishing it from sealing or discarding operations, though it doesn't explicitly differentiate from the bulk update sibling.

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

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

It provides a clear when-to-use condition: 'Only meaningful while the group is OPEN — sealed groups are immutable,' which also serves as a when-not-to-use. It also gives a prerequisite chain: 'Requires: caseFileId + evidence_group_create → evidenceGroupId,' helping the agent understand dependencies, but it does not mention alternative tools like evidence_group_update_bulk.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the agent knows it's a non-read-only, non-destructive write. However, the description does not disclose bulk operation behavior such as atomicity, partial failure handling, or error semantics. The statement 'each entry carries its own evidenceGroupId and changes' conflicts with the actual schema (flat ids array), adding confusion rather than clarity.

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 front-loaded with the core action and scope. However, the sentence 'each entry carries its own evidenceGroupId and changes' is misleading and inaccurate given the schema, occupying space that could be better used for clarifying the request structure.

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 bulk update tool with patch semantics and no output schema, the description is incomplete. It omits how to structure the patch array, the relationship between ids and patch, error handling, and partial-failure behavior. The mismatch between the described 'per entry' model and the actual schema further undermines completeness.

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

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

Schema description coverage is 0%, so the description must fully explain parameters, but it barely does. It mentions 'evidenceGroupIds' and 'changes' without mapping to the actual schema properties 'ids' and 'patch'. It never explains the patch operations (REPLACE, REMOVE), path/value structure, or how patch applies to the multiple ids, and the 'each entry' phrasing actively misleads.

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 updates editable metadata of several evidence groups in one call, using a specific verb and resource. It also explicitly differentiates from the sibling tool evidence_group_update by advising to prefer that for a single group.

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 explicit usage guidance: 'Prefer evidence_group_update for a single group' and notes the prerequisite to find evidenceGroupIds via evidence_group_search. This clearly indicates when to use the bulk tool versus the single-update alternative.

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

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

Annotations already indicate readOnlyHint=false, idempotentHint=false, and destructiveHint=false. The description adds useful behavioral context: the operation starts a session rather than performing the upload itself, and returns coordinates for subsequent partial uploads. However, it does not disclose session lifecycle details, completion/abort requirements, or expiry behavior, which would be valuable for a multipart flow.

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

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

The description is compact and front-loaded: the core purpose is in the first sentence, followed by the usage condition and prerequisite in the second. Every sentence adds information. It is slightly dense and the phrase 'upload coordinates' is imprecise, but overall it is 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?

This is a complex tool with 10 parameters, 6 required fields, nested objects, no output schema, and nontrivial session semantics. The description mentions that upload coordinates are returned but does not describe required fields, the response shape, or the expected follow-up steps for completing the multipart upload. It is not complete enough for an agent to invoke this correctly without additional guidance.

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

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

Schema description coverage is only 30%, and the description compensates only for evidenceId and fileName, mentioning that evidenceId comes from evidence_group_evidence_register or generate_evidence. The schema also contains confusing 'MANDATORY' labels on optional UUID fields, and the description does not clarify the required createdBy, title, capturedAt, and testimony parameters. This leaves a substantial parameter-semantics gap.

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

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

The description states a specific action ('Starts a MULTIPART upload session') on a specific resource ('a large evidence file') and explains what it returns ('upload coordinates for uploading the file in parts'). It also distinguishes itself from the single-presigned-PUT flow by noting this is for cases where a single PUT is not enough, which separates it from siblings like evidence_upload_url_create.

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

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

The description gives clear when-to-use guidance: 'Use when a single presigned PUT is not enough for the file size.' It also provides the prerequisite that the evidence must already be registered and references the precise tools used to obtain the required evidenceId. It does not explicitly name alternative tools 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?

Annotations already declare destructiveHint=true, but the description adds substantial context: the deletion is permanent, the signed document and package stop being downloadable, and the underlying case file/evidence are unaffected. This goes far beyond the structured safety hints and sets proper 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?

Four short sentences, each earning their place: purpose, destruction consequence, prerequisite, and scope boundary. No filler or redundancy; critical information is front-loaded and clearly 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?

For a simple delete tool with one parameter, the description covers all essential context: what is deleted (report), what becomes unavailable (downloadable document and package), what is required (prior generation), and what is not affected (case file and evidence). Combined with the annotations (destructive, idempotent), the agent has full situational awareness.

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

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

The schema already provides 100% coverage with reportId described as 'MANDATORY. UUID of the report.' The description adds provenance by linking reportId to evidence_case_file_report_generate, telling the agent where to obtain a valid ID. This is a meaningful addition 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 opens with a specific verb and resource: 'Permanently deletes a generated report by its reportId.' This clearly distinguishes it from sibling report tools like pdf_url_get or zip_url_get, and from case-file deletion tools.

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

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

The description explicitly states the prerequisite: 'Requires: evidence_case_file_report_generate → reportId.' It also declares a clear boundary: 'The underlying case file and its evidence are NOT touched.' This tells the agent when to use the tool and what it will not do, effectively guiding against misuse.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds useful context: the resource is a signed PDF, the returned URL is the same as the sibling tool's, and prior generation is required. This goes beyond annotations without contradicting them.

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

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

Two sentences do exactly what is needed: front-load the purpose, then provide conditions, sibling distinction, and prerequisite. No filler or redundant phrasing; every clause earns its place.

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

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

With a single parameter, full annotations, and an output schema, the description fully covers purpose, usage, and prerequisite. The tool is simple enough that no additional behavioral or return-value details are required.

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?

Input schema fully covers the parameter (reportId as required UUID). The description adds semantic meaning by clarifying that only reportId is needed and linking it to the generate step, which enriches understanding beyond the schema's format and description.

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

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

The description clearly states the tool retrieves a download URL for a report's signed PDF using only reportId, and explicitly distinguishes it from the sibling evidence_case_file_report_pdf_url_get by noting that no caseFileId is needed and that it returns the same document. This makes the purpose unambiguous.

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

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

It provides explicit usage conditions: use when holding only reportId, with no caseFileId required. It names the alternative sibling and states the prerequisite chain evidence_case_file_report_generate → reportId, giving clear when-to-use and when-not-to-use 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. Description adds that it retrieves a download URL for the complete ZIP package and mentions the prerequisite, but no additional behavioral traits such as rate limits or response details. No contradiction with annotations.

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 two sentences. First sentence states purpose and differentiator. Second sentence provides prerequisite. Both are essential 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?

With an output schema present and annotations covering read-only behavior, the description is sufficient for a 1-parameter tool. It specifies the package returned, the precondition, and the input source. No major gaps identified.

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

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

Schema coverage is 100% with reportId described as 'MANDATORY. UUID of the report.' The description adds context by explaining that the reportId is obtained from evidence_case_file_report_generate, which is useful workflow information. However, since the schema already fully documents the parameter, the description's added value is modest.

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 uses specific verb 'Retrieves' and clearly identifies the resource: 'a report's complete ZIP package' with access condition 'when you only hold the reportId'. It explicitly references sibling tool evidence_case_file_report_zip_url_get, clarifying it returns the same package, which distinguishes it from other evidence/report 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 phrase 'when you only hold the reportId' provides a clear usage context, implying this tool is for reportId-based access rather than case-file-based access. It also states the prerequisite 'Requires: evidence_case_file_report_generate → reportId', which tells the user the required prior step. However, it doesn't explicitly list alternative tools to use in other situations.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds context about tenant-wide scope and that it is not group-scoped, which is useful, but it does not disclose pagination behavior or response structure beyond mentioning 'pagination' as an optional filter. Given the strong annotation coverage, this is acceptable but not exceptional.

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 exactly two sentences, front-loaded with the core action and scope, followed by usage guidance and the alternative tool. No wasted words; every clause earns its place.

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

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

While the tool has a rich output schema and annotations cover safety, the description does not adequately explain the many filter parameters or pagination semantics. The schema coverage is 0% and the description only hints at a few filter types, so an agent cannot reliably construct a well-formed query without additional context. The alternative routing and scope are helpful, but the parameter space is under-documented for a tool of this complexity.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining the filter object's many fields. The description only mentions 'state, dates, pagination' as examples, which are vague and do not map cleanly to the actual property names (e.g., status, capturedFrom/capturedUntil, page/size). It fails to mention numerous other filters like id, hash, type, title, groupId, fileName, fileSize, metadata, groupType, caseFileId, custodyType, testimonyMode, and collectionMetadata, leaving the agent under-informed for constructing effective queries.

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

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

The description states a clear verb ('Searches') and resource ('evidences across the tenant'), specifies scope ('not scoped to one group'), and names the primary use cases (find an evidenceId, audit what exists). It explicitly differentiates itself from the sibling tool evidence_group_get, so an agent can distinguish them without opening schemas.

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

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

It gives explicit when-to-use guidance ('Use to find an evidenceId or audit what exists') and a direct when-not-to-use with an alternative ('for one group's content use evidence_group_get instead'). This fully routes the agent to the correct tool for the two main scenarios.

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

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

Annotations provide no positive safety hints (all false), so the description carries the burden. It usefully discloses that the operation only creates a URL and does not register the file, and it frames the temporary staging lifecycle. However, it omits details such as URL expiration, upload method, side effects, or what happens if the staged file is never referenced.

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

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

Two sentences with no filler. The core action is front-loaded, the staging use case is stated, and alternatives are named compactly in the second sentence.

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

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

This is a 10-parameter tool with nested objects, no output schema, and no useful annotations, yet the description only covers purpose and high-level usage. It does not explain the returned URL, required ID relationships, or upload semantics, so an agent lacks critical information needed to invoke it correctly.

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

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

Schema description coverage is only 30%, and the description adds no parameter-level guidance. It never explains required fields like evidenceId, createdBy, title, capturedAt, fileName, or testimony. The schema also self-contradicts by labeling caseFileId 'MANDATORY' while not listing it in the required array, and the description does nothing to resolve this.

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+resource combination: 'Creates a presigned upload URL for a TEMPORARY file not yet registered as evidence.' It clearly distinguishes this tool from sibling upload/registration flows by emphasizing the temporary, unregistered nature and by naming the alternatives it is not.

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

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

The description explicitly states when to use the tool ('Use for staging content that another operation will reference') and when not to ('for real evidence prefer the register-then-upload flow' and 'evidence_create_sealed composite'). It names concrete sibling alternatives, leaving no ambiguity.

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

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

Annotations already indicate readOnly and nondestructive behavior; the description adds meaningful behavioral context: the URL is temporary, it is for thumbnails only, and it avoids downloading the original. This goes beyond the structured safety hints without contradicting them.

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 brief and front-loaded with the core purpose in the first sentence, followed by requirements. However, the naming error ('evidenceGroupId' vs 'groupId') slightly undermines its otherwise efficient structure.

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?

While a simple read tool with output schema and safety annotations, the description is not fully complete: the parameter naming inconsistency could cause invocation errors, and thumbnailSize semantics are unexplained. These are material gaps for correct usage.

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

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

Schema coverage is only 50%, and the description must compensate but fails to do so adequately. It lists 'caseFileId + evidenceGroupId + evidenceId', but the actual schema parameter is 'groupId', creating a naming mismatch. It adds no meaningful detail for 'thumbnailSize' (e.g., accepted values), leaving two parameters under-described.

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 retrieves a temporary thumbnail URL for image evidence, specifying the exact verb and resource. It distinguishes itself from sibling download URL tools by emphasizing 'thumbnail' and 'without downloading the original file', making the purpose unambiguous.

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

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

Explicitly says 'use for quick visual verification without downloading the original file', providing clear context. It also notes 'image-type evidence only', which sets a boundary, though it does not name alternative tools for other use cases.

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

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

Annotations only indicate a non-read-only, non-idempotent operation, so the description carries most of the burden. It adds meaningful behavioral context: file content and hash are immutable, changed files require re-registration, and evidenceId is mandatory and must come from two named tools. This exceeds simple annotations and clarifies update boundaries without contradicting destructiveHint=false.

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

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

The description is two sentences with zero waste: the first sentence gives the main action and scope, the second adds the critical immutability constraint and prerequisite. It is front-loaded and easy to scan. It could have been slightly more explicit about which metadata fields are editable, but overall it is concise and readable.

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

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

The tool has 7 parameters, nested objects, and no output schema, yet the description covers only the general purpose and identity requirement. It omits field-level semantics (e.g., how custody, deletionDate, and deletionType are used) and whether unprovided fields are ignored or reset. An agent assembling a correct call would still have to inspect the schema heavily to understand editing behavior.

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

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

Schema description coverage is only 14%, with only evidenceId described in the schema, so the description needs to compensate. It only gives examples ('name, description') and says the target is editable metadata, but does not explain custody, metadata, createdBy, deletionDate, deletionType, or whether updates are partial vs full. Most parameters remain ambiguous from both schema and description.

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

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

The description states a specific verb and resource ('Updates a single evidence's editable metadata by evidenceId') and explicitly scopes the tool to one evidence, distinguishing it from sibling evidence_update_bulk. The mention of immutability for content/hash prevents confusion with file-modifying tools. An agent can immediately tell what this tool is for.

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 a clear when-to-use context and a strong when-not: if the file content or hash changes, the agent should re-register a new evidence instead of using this tool. It also states the prerequisite chain (evidence_group_evidence_register or generate_evidence → evidenceId), which routes the agent to correct predecessor tools. It does not explicitly name evidence_update_bulk as the alternative for multiple records, but the 'single' wording conveys that.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, so the mutation is already known. The description adds context by specifying 'editable metadata' and that each entry carries its own evidenceId and changes, giving behavioral insight beyond the schema. No contradiction with annotations.

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

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

The description is three concise sentences with no fluff. It front-loads the verb and scope, includes usage alternatives, and provides a prerequisite—all relevant information 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?

While the description covers purpose, alternatives, and prerequisite, it fails to explain the critical relationship between the 'ids' array and the 'patch' array, and does not mention return values or error behavior. Given no output schema and a bulk mutation tool, this gap leaves the description minimally viable 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?