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 signals a mutation via 'Delete', but says nothing about irreversibility, required permissions/RLS behavior, cascading effects on related rows, or whether an empty/loose filter can widen the deletion scope.

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 front-loaded sentence with no filler; the verb and resource come first. It is efficient, though its brevity contributes to the missing behavioral and filter-syntax context.

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 destructive tool with no annotations and no output schema, the description is too thin. The filter parameter is an open object (additionalProperties) whose expected condition format is documented nowhere, and no return/affected-row information is given.

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 both 'table' and 'filter' are already documented in the schema, and the description only restates them. It adds no syntax or format detail for the free-form filter object, so baseline 3 applies.

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

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

States a specific verb (Delete) and resource (rows from a Supabase table) with the scoping condition (matching filter conditions). It implicitly separates itself from supabase_delete_file by specifying 'rows from a table', but it never explicitly contrasts with supabase_update or supabase_query, so the differentiation is only partial.

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

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

No guidance on when to use this versus supabase_update, supabase_execute_sql, or supabase_delete_file. There is no warning that this is irreversible or any precondition for running it, despite being the most destructive tool 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Delete' signals a destructive, likely irreversible mutation, but the description says nothing about required permissions, what happens if the file or bucket does not exist, or whether the operation can be undone.

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 front-loaded sentence with no filler, well sized for the operation. It is efficient, though stripped so far down that it omits useful behavioral context.

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

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

For a two-parameter delete with fully documented params and no output schema, the description is minimally adequate. However, as a destructive mutation with zero annotation coverage, it should at least note irreversibility or error behavior, which it does not.

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 'bucket' and 'path' documented in the schema, so the baseline is 3. The description adds no additional syntax, format, or path-resolution detail beyond what the schema already supplies.

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 (delete) and resource (file in a Supabase storage bucket), which cleanly separates it from supabase_upload_file and supabase_list_files. It does not explicitly name an alternative sibling, but the resource scope is unambiguous.

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

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

There is no guidance on when to use this over supabase_delete or supabase_delete (row) operations, no prerequisites, and no mention that the action is irreversible. The agent must infer usage entirely from the name.

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 does disclose a meaningful prerequisite (the execute_sql function must be created), but says nothing about permissions, whether arbitrary SQL can mutate or destroy data, transaction behavior, or rate limits — critical omissions for a raw-SQL execution 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?

A single front-loaded sentence with no padding; the parenthetical prerequisite is worth its space. It could be split so the prerequisite reads as a distinct condition, but nothing is wasted.

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 that executes arbitrary SQL, with no annotations and no output schema, the description omits destructive-capability warnings, permission requirements, and return expectations. The one prerequisite given is useful but not sufficient for correct invocation.

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

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

Schema description coverage is 100% for the single 'sql' parameter, so the schema already documents it and the baseline is 3. The description's parenthetical about the execute_sql RPC function marginally reinforces the schema note but adds no syntax or format detail.

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

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

States a specific verb (Execute) and resource (raw SQL query) plus the transport (RPC endpoint), which is more informative than the sibling names supabase_query or supabase_rpc alone. It does not, however, explain how it differs from supabase_rpc or supabase_query, so the agent still has to guess which sibling to pick.

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 supplies a prerequisite (an execute_sql RPC function must exist in Supabase) but no when-to-use, when-not-to-use, or alternative-selection guidance. With eleven siblings including supabase_query and supabase_rpc, the absence of routing guidance is a real gap.

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 disclosure burden. 'Get' implies a read-only, non-destructive metadata lookup, but the description says nothing about permissions required, whether it hits the database or a cache, or whether the table must exist. It adds no behavioral context beyond the one-line purpose.

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 front-loaded sentence with no filler; every word earns its place and the resource is named before the qualifier.

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 does name what is returned ('column definitions and data types'), which partially covers the return shape. However, with no annotations and no return-format detail (nullability, defaults, keys), it is only minimally adequate for an agent deciding whether to call it.

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 a single required 'table' parameter that the schema documents as 'Table name to get schema for'. The description adds no qualifier such as schema/namespace or quoting rules, 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?

States a specific verb ('Get') and resource ('column definitions and data types for a specific table'), making the scope unmistakable. It does not explicitly differentiate itself from siblings like supabase_list_tables or supabase_query, but the metadata-vs-data distinction is implicit and 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?

No guidance on when to call this versus supabase_list_tables (which presumably enumerates tables) or supabase_execute_sql. The description contains no 'use this before X' or 'not for Y' context, leaving the agent to infer the workflow step.

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 supplied, the description carries the full behavioral burden but only says 'insert one or more rows.' It omits whether inserts require elevated permissions or RLS policy, what happens on conflict/duplicate keys, whether it is upsert-capable, and whether inserted rows are returned.

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 tight sentence with the verb and scope front-loaded and zero filler. It is efficient, though its brevity reflects minimal content rather than disciplined editing of rich material.

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 tool with fully documented schema and no output schema, the description is adequate to call the tool but leaves conflict handling, permissions, and return behavior unspecified. It is minimally viable rather than 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 100%, so both parameters are already documented in structured form, establishing a baseline of 3. The phrase 'one or more rows' loosely echoes the single-object-or-array anyOf in the schema but adds no format, key-matching, or type guidance beyond 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 states a specific verb (insert) and resource (rows into a Supabase table), making it easy to distinguish from siblings like supabase_update, supabase_delete, and supabase_query. It does not explicitly name those alternatives, but the operation itself is unambiguous.

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

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

The description gives no when-to-use guidance, no preconditions (permissions, RLS, table existence), and never points to alternatives such as supabase_rpc or batch strategies. An agent must infer entirely from the verb and the sibling list.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, yet it only states the action. It does not explicitly confirm read-only safety, mention authentication requirements, rate limits, return format, or any pagination behavior.

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

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

The description is a single, front-loaded sentence with no filler. Every word earns its place and the purpose is immediately clear.

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

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

For a zero-parameter list tool with no output schema, the description is minimally adequate for invocation. However, it does not describe what a returned bucket object contains or any usage context, leaving some ambiguity about the result shape.

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 takes zero parameters, so there are no parameter semantics to explain. The baseline score for zero parameters is 4, as the schema is effectively complete.

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 gives a specific verb ('List') and resource ('storage buckets') within a named scope ('Supabase project'). This clearly differentiates it from most siblings, but it does not explicitly name or contrast with related tools like supabase_list_files or supabase_list_tables.

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 offers no when-to-use guidance, prerequisites, or alternatives. It simply states the operation, leaving the agent to infer that this is the tool for discovering buckets.

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 and falls short: it does not say the operation is read-only, whether it requires auth, how pagination via limit/offset behaves, or what a listing returns. 'Optional path filtering' merely restates a schema field.

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 tight sentence with the resource and scope front-loaded and no wasted words. It is efficient, though terse to the point of omitting behavioral context.

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, the description should at least hint at return shape, ordering, or pagination semantics, but it omits them. It is minimally adequate for a simple list tool whose parameters are fully documented in the schema.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters including defaults and bounds. The description's mention of path filtering adds no syntax or value beyond the schema, 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?

States a specific verb and resource ('List files in a Supabase storage bucket'), which cleanly distinguishes it from supabase_list_buckets and supabase_list_tables. However, it does not explicitly name or contrast with any sibling tool.

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

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

No guidance on when to prefer this over alternatives such as supabase_query or supabase_list_buckets, and no prerequisites or exclusions are stated. Usage is only implied by the tool name and description.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose the scoping constraint that only the public schema is covered, which is genuinely useful context, but says nothing about permissions, whether the result is exhaustive, or that the operation is read-only. For a simple list tool this is adequate but thin.

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

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

A single front-loaded sentence that states verb, resource, and scope with no filler. Nothing is wasted or buried.

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

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

For a zero-parameter discovery tool with no output schema and no annotations, the description conveys what will be returned (all tables) and the scope limitation. It could mention the return shape or count, but it is sufficiently complete for correct invocation.

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

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

The tool takes zero parameters, so there is no parameter semantics to document. Baseline 4 applies, and nothing in the description conflicts with the empty 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 (List) and resource (tables) scoped to the public schema of the Supabase database, which naturally separates it from supabase_query and supabase_insert. It does not explicitly name or contrast a sibling like supabase_get_table_schema, but the verb+resource combination is unambiguous.

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

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

The description says what the tool does but gives no guidance on when to reach for it over alternatives such as supabase_get_table_schema or supabase_execute_sql. Usage is only implied (discover table names before querying), with no exclusions or prerequisites stated.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only SELECT, but says nothing about permission requirements, default/maximum row limits, how limit and offset interact, or whether any server-side caps apply. For a data-access tool with zero annotation coverage this is a notable gap.

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

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

A single well-formed sentence with the verb and resource front-loaded and no redundant filler. It could be marginally tighter or fold in a routing clause, but nothing is wasted.

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 six parameters including a free-form nested 'filter' object and no output schema or annotations, the description is only minimally adequate. It does not explain filter operator syntax, whether results are paginated by default, or what is returned, leaving an agent to infer behavior from the schema alone.

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 every parameter is already documented in the schema, making 3 the baseline. The description's mention of filtering, ordering, and pagination maps onto the params but adds no syntax, defaults, or format detail beyond what the schema states.

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

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

States a specific verb+resource combination ('Execute a SELECT query on a Supabase table') and enumerates the supported capabilities (filtering, ordering, pagination). It clearly reads as a read-only tool distinct from supabase_update/delete/insert, though it never explicitly contrasts itself with the overlapping supabase_execute_sql 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?

No guidance on when to prefer this tool over supabase_execute_sql, supabase_rpc, or supabase_list_tables. The implied read-only scope is the only routing signal, and there are no stated prerequisites or exclusions.

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

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

No annotations provided, so the description carries full burden. It does not state whether calls are read-only or mutating, whether the function executes with elevated privileges, what errors look like, or any side-effect characteristics. For an RPC invocation tool this leaves substantial unknowns.

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 efficient sentence with no waste and front-loaded verb. Slightly under-specified rather than verbose.

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

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

For a mutation-capable RPC tool with no annotations, no output schema, and a free-form args object, the description should disclose side effects, privilege/auth requirements, and how it relates to sibling tools like supabase_execute_sql. None of that is present.

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

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

Schema description coverage is 100%: both 'function' (name) and 'args' (arguments object) are documented in the schema. The description adds no format or semantic detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb (Call) and resource (stored function / RPC endpoint in Supabase). The dual phrasing 'stored function or RPC endpoint' is slightly ambiguous but the intent is clear. It does not differentiate from siblings like supabase_execute_sql, which is a meaningful gap given 12 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?

No when-to-use, when-not-to-use, or alternative guidance. An agent seeing both supabase_rpc and supabase_execute_sql has no description-level signal about which to pick.

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

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

With no annotations, the description carries the full behavioral burden, yet it says nothing about the destructive/mutating nature of the call, required permissions or RLS implications, whether an empty filter is allowed, or whether the operation is reversible. For a write tool this is a substantial 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?

A single front-loaded sentence naming the verb, resource, and filter condition with no filler. It is efficiently sized for the amount of content it actually conveys.

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 mutation tool with no annotations, no output schema, and untyped nested objects (data and filter use additionalProperties with no shape), the description should explain filter structure, expected return, and safety implications. None of that is present, leaving the definition thin relative to 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%, so table, data, and filter are already documented in the schema, and the description adds essentially nothing beyond restating the filter concept. Baseline 3 applies when the schema does the heavy lifting; no extra syntax or format detail is provided for the free-form nested objects.

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 (update), resource (rows in a Supabase table), and scope (rows matching the filter conditions), so the operation is unambiguous. It does not explicitly distinguish itself from siblings like supabase_insert, supabase_delete, or supabase_execute_sql, which would be the final step to a 5.

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

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

There is no when-to-use guidance and no mention of alternatives: an agent cannot tell from this text whether to prefer supabase_update over supabase_insert for upserts or over supabase_execute_sql for complex mutations. The only contextual cue is the implicit 'matching rows' filter.

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

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

No annotations are provided, so the description carries the full burden. It says 'Upload' but doesn't disclose whether existing files at the same path are overwritten, whether the operation requires specific bucket policies or authentication, whether it returns a public URL, or whether there are size/content restrictions. For a mutation tool with zero annotation coverage, this is a significant 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?

A single, efficient sentence with no wasted words and the core action front-loaded. It is appropriately sized for the simplicity of the operation, though it could be slightly more definitive about scope.

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 mutation tool with no annotations, no output schema, and 3 required parameters, the description should explain overwrite behavior, auth/permission requirements, and any return value (e.g., public URL). None of that is present. The high schema coverage helps parameters, but behavioral context is missing.

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

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

Schema description coverage is 100% – all four parameters (bucket, path, data, contentType) are documented in the schema with clear descriptions. The tool description adds nothing beyond what the schema already provides, which is the expected baseline when schema coverage is high.

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

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

Clear verb+resource: 'Upload a file to a Supabase storage bucket.' An agent can immediately distinguish this from siblings like supabase_list_files or supabase_delete_file by the verb and target resource. However, it doesn't differentiate against other write siblings like supabase_insert (which writes to tables, not storage), leaving some ambiguity about storage-vs-table 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?

No guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (does the bucket need to exist?), overwrite behavior, file size limits, or when to prefer supabase_insert for structured data vs. file upload for storage objects. An agent must infer usage from the name alone.

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