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

With no annotations provided, the description carries the full behavioral disclosure burden. It does a good job by revealing that the tool 'fires the collection's configured webhooks and triggers' and that data must conform to the schema, which are non-obvious side effects and constraints beyond simply 'creating a document'. It does not mention permissions or failure behavior, but the key side effects are disclosed.

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

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

The description is three tight sentences with no filler. The first sentence states the core action, the second gives the key constraint, and the third reveals side effects. Every sentence 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 that all parameters are required and documented in the schema, and the description explains the create action, schema-match constraint, and side-effect behavior, an agent has enough to invoke the tool correctly. It could optionally mention the response format, but the absence of an output schema does not make the description incomplete enough to drop below a 4.

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

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

The input schema already documents all three parameters with 100% coverage, so the baseline is 3. The description adds value by emphasizing that 'data' must match the collection's declared field schema and points agents to mudbase_get_collection for the authoritative schema, going beyond the generic schema text.

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 action explicitly: 'Create a new document in a Mudbase collection.' It identifies the resource (document), the container (collection), and the operation (create), which is clearly distinct from siblings like update, delete, or list.

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 establishes when to use the tool: when creating a new document, not updating an existing one. It also provides a prerequisite by telling agents to check the collection's field schema via mudbase_get_collection. It does not name alternatives explicitly, but the create-vs-update context is clear.

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

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

Annotations already mark destructiveHint=true, but the description adds valuable context with 'Permanently' and 'This cannot be undone', reinforcing the irreversibility and warning the agent of the consequence. It also specifies 'single document', clarifying the scope. This goes beyond the annotation without contradicting it.

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 with no redundant wording. The key action and the critical warning are front-loaded, making it efficient and easy to parse.

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

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

For a simple delete operation with fully documented parameters and no output schema, the description covers the essential information: the action, the irreversibility, and the scope. It could mention error handling or return values, but these are not necessary for the agent to invoke the tool correctly. The destructiveHint annotation covers the safety profile, so the description is complete enough.

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 descriptions cover 100% of the parameters with clear definitions (projectId, collectionId, documentId). The description adds no additional parameter-specific meaning, so a baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'delete', the resource 'document', and the scope 'single' from a 'Mudbase collection'. It is unambiguous and distinguishes from sibling tools like delete_file or update_document, making the purpose immediately clear.

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

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

The description does not explicitly mention when to use this tool versus alternatives, nor does it provide exclusions or prerequisites. The usage is implied by the action, but there is no guidance on selection criteria or when not to use it. It is adequate but not explicit.

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 mark destructiveHint, and the description goes beyond that by explicitly warning that deletion is permanent and cannot be undone. This is useful behavioral disclosure for an irreversible action.

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

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

Two short sentences carry the essential information: the action, the target, and the irreversibility. No filler or redundancy.

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

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

For a delete operation, the description covers what it does and its permanence. It doesn't explain return values or behavior on nonexistent files, but the three required parameters are all documented and no output schema exists. Minor omission, not a blocker.

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

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

The input schema already documents all three required parameters with descriptions and 100% coveragecyst. The description adds no parameter-specific detail beyond what the schema provides, so it meets but does not exceed the baseline.

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

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

The description uses a specific verb ('delete') and identifies the exact resource ('a Mudbase storage bucket' file), making the tool's purpose immediately clear and distinguishing it from document-level operations.

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 action and resource are clear, so when to use it is implied proportional to file deletion. However, it does not explicitly state when not to use it or how it differs from sibling tools like deleting a document.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'Get' strongly implies a read-only operation, and the description clarifies what is returned (schema and permissions). However, it does not explicitly state that it has no side effects, nor does it mention error behavior or authentication needs. For a simple read, 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?

A single, well-structured sentence that front-loads the core purpose ('full field schema and permission settings') and clearly identifies the target ('one collection'). There is zero 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 get operation with only two parameters and no output schema, the description covers the essential return content (schema and permissions) and scope. It does not need to elaborate on return format since the tool is straightforward. Minor missing elements like error handling are not critical for this tool type.

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% (both parameters have descriptions), so the schema already explains projectId and collectionId. The description adds no new parameter-level detail beyond confirming they identify a collection. Since schema does the heavy lifting, the description meets the baseline but adds minimal extra value.

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

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

The description states a specific verb ('Get'), a clear resource ('full field schema and permission settings'), and a scope ('one collection'). It distinguishes itself from siblings like mudbase_get_document (which likely returns a document) and mudbase_list_collections (which lists collections) without ambiguity.

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

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

The description implies usage: call this when you need a collection's schema or permission settings. However, it does not explicitly state when to choose this over alternatives, nor does it mention any preconditions or exclusions. The context is clear but not fully spelled out.

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

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

No annotations are provided, so the description carries the full burden. 'Fetch' clearly signals a read-only operation, but the description does not go beyond that to mention not-found behavior, authentication, or the shape of the returned document.

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

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

A single sentence that is front-loaded with the action and resource, with no filler or redundancy. It earns its place and leaves the schema to handle parameter 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?

For a simple ID-based read with a fully described schema and no complex output, the description is nearly sufficient. It could add a note about when to prefer list_documents, but an agent can already determine parameters from the schema and infer the return value from 'Fetch a single document'.

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 three parameters are already described in the input schema (projectId, collectionId, documentId), so the schema carries the semantic weight. The description adds no per-parameter detail or relationship among the IDs, matching the baseline for high schema coverage.

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

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

The description uses a specific verb ('Fetch'), a precise resource ('a single document by ID'), and an explicit container ('from a Mudbase collection'). 'Single' distinguishes it from list_documents and search_documents, while 'by ID' separates it from collection-level operations.

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 intended use is implied: call this when you already have an ID and need one document. However, it never names alternatives like mudbase_list_documents or says when not to use this tool, so an agent gets no explicit routing guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves metadata and lists the fields, but it does not disclose whether the file content is returned (it is not), whether the operation is read-only, whether it errors on missing files, or any access/visibility constraints. The description is accurate but thin on 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 a single, efficient sentence that front-loads the verb and resource, then lists the metadata fields. Every word earns its place; no filler 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 metadata retrieval tool with 3 fully documented parameters and no output schema, the description is mostly adequate. However, it lacks any mention of return format, error behavior, or how this differs from getting the file content/download URL. Given the sibling set includes closely related tools, a bit more context would help an agent select it confidently.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (fileId, bucketId, projectId) with clear descriptions. The tool description adds no additional parameter-level meaning beyond what the schema provides, so the baseline 3 is appropriate.

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

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

The description clearly states the verb 'Get' and the resource 'metadata for a single stored file', and enumerates the specific metadata fields (name, size, MIME type, visibility, timestamps). It distinguishes itself from sibling tools like mudbase_list_files (which lists files) and mudbase_get_file_download_url (which gets a URL), though it doesn't explicitly name those 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 implies usage: call this when you need metadata for one file rather than a list or download URL. However, it does not explicitly state when to use this tool versus alternatives like mudbase_list_files or mudbase_get_file_download_url, nor does it mention any prerequisites or context such as needing the fileId from a prior list call.

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

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

With no annotations, the description must carry the full behavioral burden. It discloses that the URL is 'time-limited' and 'signed', and that it works for 'private or public' files, providing some insight. However, it does not explicitly state the return format (e.g., plain string vs. JSON), nor does it mention error handling, authentication requirements, or any side effects. Given the absence of annotations, this is a moderate disclosure gap.

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

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

The description is a single, concise sentence (21 words) that clearly conveys the core functionality without redundancy. It is front-loaded with the main action and includes only essential details, making it efficient for an agent to parse.

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

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

The tool has no output schema and no annotations, so the description must clarify the return value and behavior. It implies a URL is returned but does not specify its format or structure. It also omits potential error conditions or prerequisites (e.g., whether the file must exist). While the parameter schema is comprehensive, the overall context for an agent is only partially complete given the simplicity of the operation.

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

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

The input schema has 100% coverage with detailed descriptions for each parameter, including defaults and bounds for expiresIn. The tool description adds no additional parameter-specific information beyond what the schema already provides. Per the rubric, with high schema coverage, the baseline is 3, and the description does not elevate 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 uses a specific verb ('Generate') and identifies the resource ('signed URL') and context ('download a private or public file from Mudbase storage'). This clearly distinguishes it from sibling tools like mudbase_get_file (likely returns file content) and upload/delete. The title reinforces the purpose as obtaining a download URL.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives (e.g., mudbase_get_file). It does not state under what conditions generating a signed URL is preferred over directly fetching the file, nor does it mention any exclusions or when not to use it. An agent must infer the use case from the description alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only states the action and gives no information about output shape, pagination behavior, default limits, error cases, or side effects. 'List' implies read-only, but important behavioral details are absent.

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 clear sentence with no filler. It front-loads the verb and resource, making the tool's purpose immediately identifiable.

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

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

With no output schema and no annotations, the description and schema cover only how to invoke the tool. Missing behavioral context like response format, pagination behavior, and relationship to sibling list tools leaves an agent without enough guidance to confidently interpret results or select 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 description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning, but the schema already documents all four parameters including pagination defaults and the search filter.

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 a specific verb ('List') and resource ('storage buckets'), and the phrase 'in a Mudbase project' clarifies scope. It distinguishes this tool from sibling list tools like mudbase_list_collections, mudbase_list_documents, and mudbase_list_files.

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

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

No guidance is given about when to use this tool versus alternatives or about workflow context beyond needing a projectId. The description implies listing buckets, but there are no explicit usage conditions or exclusions.

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

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

With no annotations provided, the description carries the behavioral burden. It discloses the full scope ('every collection'), the content of the result ('each field's name and type'), and the recommended usage context. This is sufficient for a simple read-oriented list operation, though it could mention whether any filtering or pagination exists.

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

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

The description is two short sentences with no filler. The core purpose and output scope are front-loaded, and the usage hint is placed in the second sentence 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 single-parameter listing tool with no output schema, the description is largely complete: it explains what the tool returns (collections and field types) and when to call it. It does not describe the exact response envelope, but that is less critical for a discovery-oriented read operation.

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

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

Schema description coverage is 100%: the only parameter, projectId, is described as 'The Mudbase project ID.' The tool description adds context about collections being project-scoped but does not materially extend the schema's parameter meaning. Baseline 3 is appropriate.

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

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

The description states a specific verb ('List') and a precise resource ('every collection (schema) defined in a Mudbase project'), and further clarifies that it includes field names and types. This clearly distinguishes it from sibling tools that deal with documents, buckets, or files.

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

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

The description explicitly tells the agent when to use this tool: 'Call this before reading or writing documents to see what collections and fields actually exist.' It does not enumerate alternatives or exclusions, but the guidance is concrete 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?

With no annotations at all, the description must disclose behavior itself. It conveys that the operation lists documents with pagination, sorting, and an optional filter, but it does not specify the result shape, whether sort/filter values are required, or error behavior. For a safe read-only listing this is adequate but not comprehensive.

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

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

Two sentences cover the operation's purpose and include an illustrative filter example. There is no duplicated schema detail or filler.

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

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

With no annotations and no output schema, the definition leaves the result format and failure behavior unspecified; pagination/sorting are named but not detailed. The filter example helps, but an agent lacks full information about what the call returns or how errors surface.

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 six parameters are documented in the schema, and the description adds value by explaining the optional filter through a concrete JSON example and by naming pagination and sorting. It does not need to restate the parameter schema, so this addition is meaningful.

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

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

The description uses a specific verb and resource: 'List documents in a Mudbase collection,' and it also states the available capabilities (pagination, sorting, optional filter). However, it does not distinguish itself from the sibling tool search_documents, so the agent must infer when listing is the correct operation rather than searching.

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 tells the agent what the tool does but not when to choose it over alternatives like search_documents or get_document. There is no mention of use cases, limitations, or combinations with other collection tools.

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

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

Since no annotations are provided, the description carries the behavioral burden. 'List' implies a read-only operation, and the optional search and MIME type filter add behavioral context. However, it does not disclose return format, pagination, or whether the operation is a simple read of metadata—nor does it mention any side effects beyond the implied 'list'.

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

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

The description is a single sentence, front-loaded with the verb and resource ('List the files stored...'), and every clause earns its place by adding relevant scope and optional filter details. No filler or redundancy.

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

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

With no output schema and no annotations, the description should state what kind of data is returned—whether it is a list of file names, metadata object, or paginated result. The description omits return details and does not mention the pagination parameters that exist in the schema, leaving an agent to infer the behavior from the schema or sibling patterns.

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

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

The input schema already describes all 6 parameters with 100% coverage, so the description does not need to add parameter semantics. It does mention 'search' and 'MIME type filter', but these simply echo schema descriptions without adding new meaning such as case sensitivity, exact-match behavior, or how filters combine.

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 ('List') and a precise resource ('files in a Mudbase storage bucket'), and clearly distinguishes it from sibling tools like `mudbase_list_documents` or `mudbase_list_buckets`. It also scopes the action to 'one' bucket, which adds specificity.

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

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

The description implies the use case—enumerate files—but it does not explicitly say when to choose this tool over alternatives such as `mudbase_search_documents` or `mudbase_list_documents`. There are no exclusions, prerequisites, or conditions for when the filters should be used.

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

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

No annotations are provided, so the description carries the entire burden of behavioral disclosure. It only repeats the purpose and optional scoping without stating that this is a read-only operation, how results are returned, whether match highlights/rankings are included, or any pagination/limit behavior beyond the schema. It leaves the agent guessing about the actual invocation outcome.

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

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

Two short sentences, each carrying distinct information: the primary function and the optional scoping feature. No filler or redundant wording, and the most important purpose is front-loaded.

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

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

The parameters are fully documented in the schema, so the invocation surface is clear. But with no output schema and no annotations, the agent still lacks guidance on the return shape, the distinction from list_documents in practice, and any edge-case behavior. The description is minimally viable but leaves several practical holes.

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

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

Schema description coverage is 100%, so baseline is 3. The description's phrase 'Optionally scope to specific collections or fields' minimally reinforces the existing `collections` and `fields` parameter descriptions but doesn't clarify the projectId/query/intent or how the optional parameters interact. It adds almost no semantic 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?

States a specific verb ('search') and resource ('a Mudbase project's collections'), and distinguishes itself from siblings like list/get/documents or collection tools. The phrase 'Full-text search' and the optional collection/field scoping clearly identify 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 use case is implied by 'Full-text search' — an agent can infer it is for text-based lookup across collections. However, it does not explicitly name alternatives like mudbase_list_documents or give when-not conditions, leaving some ambiguity about when to choose this over a list tool.

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

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

With no annotations, the description carries the transparency burden and does a solid job: it discloses that this is a partial update and that omitted fields are left untouched, a key behavioral trait that prevents an agent from assuming the entire document is replaced. It does not cover auth, errors, or response shape, but the core mutation behavior is clearly communicated.

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

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

The description is two sentences with no filler. The first sentence front-loads the core verb and resource, while the second sentence explains exactly how the 'data' parameter is applied, making every sentence earn 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 four-parameter tool with a fully described schema, this description is nearly sufficient to invoke the tool correctly. The main gap is the absence of any mention of return values or error behavior, but that does not block correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning to the 'data' parameter: it is the only source of changes, and fields omitted from it are preserved. This goes beyond the schema's generic 'document fields as a plain JSON object' 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 action ('partially update') and the resource ('an existing document'), and distinguishes this from create/delete by emphasizing that the document already exists. It does not explicitly name or contrast sibling tools, but the partial-update semantics are unambiguous.

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

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

The phrase 'existing document' and the explanation that only fields in 'data' are changed imply this tool should be used when modifying a subset of an existing document's fields. However, there are no explicit when-to-use, when-not-to-use, or alternative tool references, so usage guidance is only implied.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a create/write operation but does not mention permissions, overwrite behavior, failure conditions, or the response/return value, all of which matter for an upload mutation.

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 and the main purpose is front-loaded. The statement about small-to-moderate files and base64 encoding earns its place, and there is no unnecessary padding.

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

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

The description covers the core task and the inline base64 mechanism, but with no output schema and no annotations it omits what the caller gets back on success or failure and any side-effect details. The schema handles parameter-level completeness, but behavioral completeness is still lacking.

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

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

The schema already documents all parameters with 100% coverage. The description adds the base64 encoding hint, but that repeats what the schema says for contentBase64, and the small-file guidance is tool-level rather than parameter-level, so it adds no real semantic value beyond the schema.

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

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

The first sentence states a specific verb and resource ('Upload a file to a Mudbase storage bucket'). The sibling tools are all document/bucket listing, retrieval, or deletion operations, so this tool is clearly distinguishable by its upload action.

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 it is best for small-to-moderate files passed inline and that it is not intended for very large binaries, which gives agents a clear applicability boundary. It does not name an alternative upload path for large binaries, so it stops one step short of full guidance.

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