Leadbase

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely useful behavior beyond that: the call is free, 'available' excludes reserved credits, 'used' is settled usage only, percentages reflect current allocation not lifetime balance, and null means no allocation.

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?

Purpose and cost are front-loaded, followed by field semantics and the usage caveat. Four dense sentences, each carrying information, though the field-definition clauses make it slightly heavy for a zero-argument read.

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, the description need not enumerate return values, and it covers purpose, cost, field caveats, and when to check. It is complete enough for an agent to call and interpret 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?

The tool takes zero parameters, so there is nothing to document and the baseline is 4. The description correctly spends no space on parameter syntax.

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

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

The description opens with a specific verb and resource: 'Read the current workspace plan and credit balance.' An agent immediately knows exactly what this returns, and no sibling tool competes for this purpose (all siblings are sheets_/enrichment_ 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?

It states when to use it ('Check this before planning more paid work') and adds a guardrail that balance does not authorize work beyond the user request. There is no named alternative, but none exists in the sibling set, so the routing context is adequate.

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 closed-world, so the safety profile is covered. The description adds genuine non-obvious behavior the annotations cannot convey: a Pending job 'continues independently of this connection', which tells the agent this is an async polling read rather than a synchronous result fetch.

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 tight sentences with the lifecycle caveat front-loaded after the core purpose. Minor overlap with the output schema in the final sentence, but every clause carries 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?

Return values are partly covered by the existing output schema, and the async lifecycle note is a strong addition. What's missing is the sourcing of batchId and the relationship to enrichment_list and enrichment_reconcile, which an agent needs to sequence these calls correctly.

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

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

Schema description coverage is 0% — batchId has no description, no format guidance, and no hint about how to obtain it. The description never mentions the parameter, so it fails to compensate for the coverage gap, though it does at least imply the tool is keyed on a specific job.

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?

Names a specific verb ('Read') and resource ('a durable research job in the current workspace'), so the operation is unambiguous. It does not, however, distinguish itself from the neighboring enrichment_list or enrichment_reconcile, leaving the singular-vs-list distinction to be inferred.

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 explicit when-to-use guidance: nothing says to call this when you already hold a batchId versus using enrichment_list to discover one, and enrichment_reconcile is never mentioned as the alternative for resolving a settled job. The usage context is only weakly implied by the word 'Read'.

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, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description only adds that results are workspace-scoped and ordered by recency; it says nothing about pagination, how 'most recent' is bounded, or limit behavior, so it adds modest value over 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?

A single front-loaded sentence with no filler. It is efficiently sized for a simple list tool, though at this length the terseness is part of why other dimensions are thin.

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

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

An output schema exists, so return values need not be explained. However, for a required-parameter listing tool the description omits the only input's semantics and any indication of result volume or ordering guarantees, leaving it minimally but not fully complete.

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

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

Schema description coverage is 0% and the single required parameter 'limit' (integer, 1-100) is never mentioned in the description. Since coverage is well under 50%, the description needs to compensate for the undocumented parameter but does not, leaving the agent to guess at the meaning and bounds of 'limit' and whether large limits are truncated.

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 ('research jobs') scoped to the current workspace with an implicit ordering ('most recent'). The one wrinkle is that the tool is named enrichment_list while the description says 'research jobs', which sits alongside sibling tools like sheets_research/sheets_research_status, so the resource identity is slightly ambiguous, and no sibling (enrichment_get, enrichment_start) is named.

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 guidance and no alternatives named. The agent is left to infer that this is the bulk-listing counterpart to enrichment_get, and there is no indication of when listing is preferable to fetching or starting a job.

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/destructiveHint=false, so the safety profile is covered. The description adds genuinely non-obvious behavioral context: it is a read-only entrypoint and does not incur paid research, and the query reaches sheets outside the initial page. The phrase "browse, search and edit" sits in mild tension with readOnlyHint, but the explicit "read-only entrypoint" clause resolves 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?

Three tight sentences with the core action front-loaded and no filler. The only slight cost is the ambiguous "edit" in the opening sentence, which forces the reader to reconcile it with the following "read-only" clause.

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?

A rich annotation set plus an output schema mean safety and return values need not be re-explained, and the description covers the remaining gaps (read-only, no paid research, query reach). It is nearly complete for a single-optional-param entrypoint; only sibling routing is absent.

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 carry the param meaning. It does: "Pass a query to search across the accessible catalogue, including sheets outside the initial page" explains both the query's function and its reach beyond the default page, which the schema's pattern/maxLength do not convey.

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 ("Open the connected Leadbase workspace") plus the scope of what the workspace enables (browse, search, edit sheets), which goes beyond simply restating the name. It does not, however, differentiate itself from overlapping siblings like sheet_workspace, workspace_search, or sheets_search.

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 one useful negative signal — "does not start paid research" — which implicitly routes cost-incurring work to sheets_research/enrichment_start. But it never states when to use this entrypoint versus the numerous search/list siblings, so usage 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?

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so safety is covered; the description adds useful behavioral facts beyond them — results are exact (not sampled), computed server-side, and capped at 20 metrics. However it does not explain the required expectedRevision parameter's conflict/staleness behavior, which is the one genuinely non-obvious behavioral trait an agent needs.

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 dense sentences with the aggregation capability front-loaded and no filler. The closing clause about snapshotRevision is terse enough to be slightly cryptic and would read better explicitly tied to expectedRevision, 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?

An output schema exists, so return-shape explanation is not required, and the description covers the operation set, the metric cap, and the exactness guarantee. The main missing piece, expectedRevision semantics, is real but is the only substantive gap for a read-only idempotent 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?

With 0% schema description coverage the description must compensate, and it partially does: it maps 'metrics' to the operation families and states the 20-metric cap, and 'filters or search' alludes to the query object's q field. It says nothing about expectedRevision (required, nullable, revision-matching semantics), alias uniqueness, or the 10-filter bound, leaving key parameters unexplained in both places.

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 (compute) and resource (exact server-side metrics) and enumerates the supported operations: row count, non-empty count, distinct count, and numeric sum/average/minimum/maximum. It clearly distinguishes the tool as an aggregation operation rather than a row-returning one, but never names a sibling such as sheets_query or sheets_search_rows to make the boundary 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 phrase 'over all rows matching bounded filters or search' implies the tool is for filtered aggregation, and 'Pin repeated analysis with returned snapshotRevision' hints at a repeated-analysis use case, but there is no explicit when-to-use versus sheets_query/sheets_search_rows split and no statement of exclusions or prerequisites.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds that the export is bounded and UTF-8, but it does not explain revision conflicts, error behavior, or what happens when maxBytes is exceeded.

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 direct sentences with the core operation front-loaded and no wasted wording. The larger-sheet fallback follows immediately as actionable 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?

The output schema means return values need no explanation, but the description does not cover expectedRevision, which is required for correct invocation. For a tool with three required parameters and 0% schema description coverage, this is a significant completeness 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 0%, so the description must compensate for three required parameters. It hints at maxBytes ("bounded") and sheetId ("current sheet"), but expectedRevision is never mentioned, leaving a required concurrency parameter completely 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 states a specific verb (Export), resource (current sheet), scope (bounded), and format (UTF-8 CSV). It also distinguishes the operation from handling larger sheets, so an agent can tell what this tool is for without opening the schema.

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 a clear condition and an alternative: use this for bounded current sheets, and for larger sheets query pages and assemble CSV in CodeMode. It does not name the exact sibling tool or provide any other when-not guidance, so it is helpful but not fully 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 already declare readOnlyHint, idempotentHint, and non-destructive, and an output schema exists, so the safety and return-format burdens are largely carried elsewhere. The description still adds workflow context (pre-edit metadata fetch, preserving existing schema/data) that is not encoded in any structured 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?

Three tight sentences, front-loaded with the primary purpose, then constraints, then alternatives. No filler or restatement of the title.

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 one-parameter, read-only metadata getter with an existing output schema and full annotation coverage, the agent has everything needed: what it returns, when to call it, and what to call instead.

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

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

Schema description coverage is 0% and the single sheetId parameter is never mentioned in the description. The schema's format:uuid gives partial signal, but the description does nothing to clarify the identifier, so it neither compensates nor adds value here.

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

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

States a specific verb (Get) and resource (sheet metadata) and enumerates exactly what comes back: column types, stable IDs, option IDs, versions. It explicitly distinguishes itself from sheets_query for cell values and from create/add-column receipts for newly created sheets, so an agent can route correctly without opening a schema.

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?

Gives an explicit when-to-use trigger (read metadata before editing an existing sheet) and names two alternatives with the condition that selects them: reuse receipts for fresh sheets, and sheets_query for cell values. This is close to a complete routing rule.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds one genuinely useful trait beyond the annotations, that invalid-value examples are bounded, but discloses nothing about auth, latency, or how progress/completion is represented.

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 filler, and the key traits (progress, completion, bounded invalid values) are front-loaded. It is well-sized, though the terse phrasing sacrifices routing and parameter information that a slightly longer sentence could carry.

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

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

An output schema means return values need not be explained, but with 0% parameter coverage on two required UUIDs and no link to sheets_copy_column, the agent lacks the context needed to obtain a valid jobId or decide when this call is appropriate.

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 both required parameters (jobId, sheetId) are undocumented anywhere. The description mentions a 'column copy' job indirectly but never maps meaning onto jobId or sheetId, leaving the agent to guess which UUID is the copy-job identifier versus the sheet.

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 (Read) and resource (durable column copy) plus what it reports: progress, completion, and invalid-value examples. It clearly reads as a status/result lookup, but it never names the sibling that initiates the copy (sheets_copy_column), so an agent must infer the pairing from the name alone.

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 explicit when-to-use guidance. The description implies this is a polling/result-read for a previously started column copy, but it never says to call it after sheets_copy_column, nor when to stop polling or what to do on an incomplete job.

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 cover the safety profile (readOnly, idempotent, non-destructive), but the description adds substantive behavioral context: the proposals 'have not been applied', the returned evidence fields, and the 'cite only sources supporting the proposed outcome' constraint. It stops short of documenting pagination or limits on the returned set.

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 compact sentences, front-loaded with the read scope followed by return fields and then the usage constraint. No filler, though the return-field listing is somewhat 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?

An output schema exists, so return values need not be explained, yet the description still enumerates them and ties the tool to the review workflow. Combined with the read-only annotations, an agent has what it needs, with only minor gaps around result limits.

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. It implies the two parameters ('specified sheet rows', sheet context) but adds no detail on the rowIds array constraints (uuid format, 1–500 items) or the sheetId format, leaving the schema to do most of the work.

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+scope: 'Read attached, completed enrichment proposals for the specified sheet rows.' This clearly distinguishes it from siblings such as sheets_review_enrichment_proposals and sheets_get_enrichment_status without needing to open any schema.

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?

Names the downstream tool explicitly ('Review with sheets_review_enrichment_proposals') and adds a prohibition ('never copy proposals into unfenced cell writes'), which directs correct usage. It does not state explicit exclusions or when not to call it, so it falls short of a full 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 cover the safe-read profile, and the description still adds substantial behavioral context: counts cover the entire selected scope, offset/limit page newest-first, each runId maps to exactly one cell, null evidence or empty sources mean no citation. The billing semantics are especially valuable: settledCredits is the confirmed subtotal (never a quote), pending=true means accounting is incomplete even if the subtotal is zero, and only pending=false establishes a final total.

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?

Purpose is front-loaded in the first clause, and the remaining sentences are dense with load-bearing information rather than filler. It is long (roughly ten clauses) and shifts without signposting between scope, pagination, evidence, billing, and exclusions, but 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?

An output schema exists, yet the description still explains the semantics of returned fields (evidence, sources, billing.settledCredits, billing.pending) which the schema alone could not convey. Combined with the scoping exclusions and pagination contract, an agent has enough to invoke and interpret the call correctly; only the sibling routing gap remains.

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 and largely does: rowIds and rowRange intersect when both are supplied, null means unrestricted, and offset/limit page individual runs newest first. sheetId and columnIds are not described, but 'for a sheet' and 'counts by column' make them self-evident. Numeric bounds are left to 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?

Opens with a specific verb+resource+scope: 'Read current cell-run status and counts by column for a sheet, explicit row/column IDs, or a row range.' An agent knows exactly what it gets. However, it never names or contrasts with the many sibling status tools (enrichment_get, enrichment_list, sheets_get_enrichment_proposals), so disambiguation from siblings is left to inference.

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 offers one concrete routing rule ('Read saved values through sheets.query and distinguish unapplied proposals') and a scoping exclusion ('No batch IDs, staff diagnostics, paid work or replay'). But much of the guidance is about interpreting returned data rather than when to call this tool versus enrichment_get, enrichment_list, or sheets_get_enrichment_proposals. Usage is implied rather than 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 already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds the "visible" scope qualifier (implying archived folders are excluded) and that only the first sheet page is returned, but it does not explain pagination continuation or auth requirements beyond what annotations supply.

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 enumerating the returned artifacts with zero filler. It is tightly sized for a low-complexity read 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?

An output schema exists, so return values need not be detailed, and annotations cover the safety profile. What is missing is how the "first sheet page" relates to the sheets_list_folder_page sibling for retrieving further pages, which an agent needs to avoid truncated results.

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

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

There is one parameter (folderId, uuid string) with 0% schema description coverage, and the description adds no meaning beyond the name. Fortunately the parameter is largely self-evident, so no strong compensation is needed, matching the baseline for a single well-named required 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?

Specific verb+resource ("Get one visible folder") plus an enumeration of what is returned (breadcrumbs, direct child folders, first sheet page). This distinguishes it from generic siblings like sheets_get and sheets_list, though it never names those alternatives explicitly.

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 or when-not-to-use guidance is offered. The mention of "first sheet page" hints that a sibling (sheets_list_folder_page) handles continuation, but the description never states this relationship or any precondition for calling the 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, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds only the 'committed' qualifier and does not disclose return format, auth needs, or retrieval constraints beyond what annotations provide.

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 or repetition. It states the core operation immediately and efficiently.

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 operation with an output schema and rich annotations, the description is minimally sufficient to identify the tool. However, it omits how to obtain a valid revision and does not clarify its relationship to sibling history/version tools.

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

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

Schema description coverage is 0%, and the description does not explain the meaning, source, or expected format of 'revision' or 'sheetId' beyond the schema types. With two required parameters and no textual parameter guidance, the description fails to compensate for 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 gives a specific verb ('Get') and resource ('one committed sheet history revision'), making the operation clear. It implicitly distinguishes from list-style siblings by saying 'one,' though it does not name an alternative tool explicitly.

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 explicit guidance on when to use this tool versus siblings like sheets_list_history or sheets_get_version_restore. The intended workflow—likely list history then fetch a specific revision—is only implied, not 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered structurally. The description adds only the enumeration of what the ACL read surfaces, which is modest added value; it does not mention permissions required or freshness of the ACL data.

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 compact sentence with zero filler, front-loading the verb and the returned ACL components. It is a fragment rather than a full sentence, 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?

An output schema is present, so return values need not be re-explained, and the annotations carry the safety profile. For a single-parameter read of sharing metadata, the description plus structured fields cover what an agent needs 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 0%, so the sole parameter (sheetId, uuid) is undocumented in both schema and description. The parameter is largely self-evident from its name and format, so the description's silence is a gap but not crippling; 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?

States a specific verb ('Read') and the resource it operates on (a sheet's sharing/ACL data), and enumerates the components returned (users, invitations, team access, publications, owner, ACL version). It is clear what the tool does, though it does not explicitly distinguish itself from near-neighbors such as sheets_get or view_sheet.

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 or when-not-to-use guidance and names no alternative. With siblings like sheets_get_team_access-style read tools in the list, an agent gets no routing help from this text.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds the useful semantic that the job returned is the 'active or most recent durable' one, but says nothing about what happens when no job exists or how job identity is reported.

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; it earns its place. It is arguably too terse for the information an agent needs, but nothing in it 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?

An output schema exists, so return-value explanation is not required, and annotations cover the safety profile. However, with 0% schema coverage and no usage context, the description leaves the agent without enough to confidently pick this tool over the restore-related siblings.

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

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

Schema description coverage is 0% and the single required parameter (sheetId, uuid) is never mentioned in the description. The parameter is self-evident from its name, but the description does not compensate for the missing schema documentation as the guidelines require at 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?

States a specific verb ('Get') and resource ('durable version restore job') with a scoping qualifier ('active or most recent'). An agent can distinguish it from mutating siblings like sheets_restore_version and sheets_restart_version_restore, though it never names them explicitly.

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 indication of when to use this versus sheets_get_history_revision, sheets_list_named_versions, sheets_restore_version, or sheets_restart_version_restore. The 'active or most recent' wording implies polling a job, but that inference is left entirely to the agent.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds the 'visible/authenticated' scoping and the category structure, which is useful, but says nothing about pagination, result limits, or freshness that a catalogue listing would benefit from.

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 led by the verb 'List', with the category enumeration earning its space by defining the output grouping. No filler or redundant restatement of the title.

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 read tool with rich annotations and an output schema, the description covers scope and content adequately. Return values are handled by the output schema, though pagination behavior for a potentially large catalogue is left unaddressed.

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 per the baseline this scores 4. There is no argument syntax for the description to clarify, and schema coverage is moot.

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 (authenticated user's visible sheet catalogue) and specifies the returned grouping (private, team, shared-with-me, public, recent) plus folders. An agent can tell it retrieves a catalogue rather than content. It stops short of naming siblings like sheets_search or sheets_list_archived, so it is clear but not sibling-differentiated.

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?

Usage is implied by the content description (browse what sheets exist), but there is no explicit when-to-use, no exclusions, and no named alternative among the many list/search siblings. The agent must infer that this is the browsing entry point.

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 the operation read-only, idempotent, closed-world, and non-destructive, so the safety profile is covered. The description adds non-obvious behavioral scope: results are limited to "owner-restorable" items (not everything archived) and include purge deadlines, which tells the agent the listing will surface retention pressure.

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 and no repetition of the title. Every clause (list, archived roots, owner-restorable, purge deadlines) carries distinct 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?

An output schema exists, so return values need not be described; with zero parameters and full annotation coverage the description only needs to convey scope and it does. Minor ambiguity remains around "roots" (whether descendants are excluded) and result ordering/pagination, which the description leaves 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?

The tool takes zero parameters and the schema coverage is 100%, so there is nothing for the description to disambiguate. Baseline 4 applies; no parameter detail is needed or missing.

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?

Specific verb ("List") plus a precisely scoped resource: archived sheet AND folder roots, restricted to "owner-restorable" items, returning purge deadlines. An agent can distinguish this from siblings such as sheets_list, sheets_list_folder_page, and sheets_restore without opening any schema.

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?

Usage is implied by the qualifiers: you call this to discover archived items that are still restorable before a purge deadline. However, with ~60 siblings including sheets_restore and sheets_restore_folder, the description never states the follow-up or the when-not (e.g., use sheets_list for live sheets).

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, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered without the description. The description's only added behavioral detail is that results are ACL-filtered, which is useful but thin; it says nothing about page size, exhaustion signals, or ordering.

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?

One sentence, front-loaded with the verb and resource, no filler or redundancy. Nothing could be trimmed without losing 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?

An output schema exists, so return values need not be described. However, for a cursor-paginated list tool the description omits the pagination lifecycle (initial call, termination condition) and any differentiation from the many other list-style siblings, leaving a real 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 0% for both parameters, so the description must carry the meaning. 'Inside a folder' loosely maps to folderId and 'next ... page' hints that cursor is a continuation token, but the schema allows cursor to be null and the description never explains that null starts the first page — the single most important usage detail for a pagination cursor.

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: 'Read the next ACL-filtered page of sheets directly inside a folder.' That is clearly a paginated folder-scoped list operation, and 'ACL-filtered' adds real meaning. It does not, however, distinguish itself from nearby siblings such as sheets_list, sheets_list_archived, or sheets_get_folder.

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 explicit when-to-use guidance and no named alternative. The word 'next' weakly implies this is a continuation call, but the agent is never told what to call first or how this differs from sheets_list or sheets_get_folder.

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=false, so the safety profile is covered. The description adds genuinely new behavior: results are committed-only, ordered newest first, and paged backwards via a revision cursor. It says nothing about rate limits, page-size behavior, or what happens at the end of history.

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, no filler, with the core action and ordering front-loaded before the pagination instruction. 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?

An output schema exists so return values need not be described, and annotations cover the safety profile; the cursor semantics are the one thing an agent could not get elsewhere and they are present. What's missing is a note on what a 'changeset' represents or whether sheetId scopes the listing, which would matter 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 coverage is 0%, so the description must carry parameter meaning, and it does explain that beforeRevision acts as a backward cursor into older history — useful beyond the bare 'numeric string or null' schema. However, sheetId and limit (including the 1-100 bound) get no semantic treatment, so the compensation is 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 ('List committed sheet changesets') plus the ordering ('newest first'), which is enough to distinguish it from the singular sheets_get_history_revision. It stops short of naming that sibling explicitly, so an agent must still infer which of the history tools 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?

'Follow beforeRevision for older history' is a real usage hint that tells the agent how to paginate rather than why to pick this tool. There is no statement of when to use it versus sheets_get_history_revision, sheets_get_version_restore, or sheets_undo/redo, so the routing 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, covering the safety profile fully. The description adds only the nuance that names are 'permanent' and attached to 'committed' revisions, which helps distinguish named versions from transient history but is thin beyond that; no pagination, scope, or result-shape context is given.

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 or redundancy. It is arguably too terse for the tool's place in a crowded namespace, but judged purely on economy and structure 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?

The tool is a simple one-parameter read operation with an output schema, so return values need not be explained, and annotations cover safety. However, nothing tells the agent how this list relates to sheets_list_history or the version-restore family, which is the main missing context for correct selection.

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 would need to carry parameter meaning, and it does not mention sheetId at all. The single parameter is a self-evident UUID identifier, so the name does nearly all the work, but the description adds nothing 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?

States a specific verb (List) and a well-defined resource: permanent names assigned to committed sheet revisions, i.e. named versions. This is distinguishable from the other list siblings (sheets_list, sheets_list_history, sheets_list_archived), though the description never explicitly names those alternatives or uses the term 'named version' that the title and sibling tools (sheets_create_named_version, sheets_rename_named_version) use.

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 such as sheets_list_history or sheets_get_version_restore. An agent must infer from the name alone whether this or a history-listing tool is the right 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?

Annotations already cover the read-only/idempotent/non-destructive profile, yet the description adds substantial context beyond them: read page.cells[].value not rawValue, email/phone remain arrays, phone normalization rules, evidence.applied=false means an unapplied proposal, null evidence/empty sources yield no citation, and external source text is untrusted data never instructions (a prompt-injection warning). This is rich behavioral disclosure an agent could not infer from 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 core purpose is front-loaded and every sentence is substantive rather than filler. It is dense and hops between value semantics, evidence rules, pagination, and versioning, which makes it a long read, but no sentence is clearly expendable.

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

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

An output schema exists, so return-value documentation is not strictly required, yet the description usefully clarifies the tricky value/rawValue and evidence semantics anyway. Given the tool's complexity, the main gap is the unexplained query sub-fields, but the agent has enough to call it correctly.

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

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

Schema description coverage is 0%, so the description must carry the load. It explains some parameters well (snapshotRevision to reuse as expectedRevision, nextCursor as opaque, projecting only needed columnIds, expectedVersion 0 vs entityVersion for writes), but the nested query fields q, sort, filters, history, version, pageSize, direction and focusRowId are never given meaning. It compensates partially rather than fully for a deeply nested 4-parameter 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?

Opens with a specific verb and resource plus scope: 'Read one revision-consistent, bounded page of rows and sparse typed cells.' It further distinguishes itself from siblings by naming sheets_aggregate for counts/statistics and positioning itself as the tool for verifying saved values, so an agent can route without opening another schema.

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?

Gives an explicit alternative ('Use sheets_aggregate for ordinary counts/statistics instead of scanning pages') and a usage directive ('For enrichment progress read values and presence, never sleep-wait inside execute'), plus how to paginate via nextCursor. It stops short of full when-not coverage (e.g., when to prefer sheets_get or sheets_search_rows over a full page scan), 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds one extra fact beyond that -- 'No research is started' -- confirming this is a pure observation call, but it says nothing about permissions, freshness, or what 'target' means.

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 with the read scope front-loaded and the no-side-effect caveat second. No filler, though 'latest list research status and target' is a slightly tangled noun phrase.

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

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

An output schema exists, so return values need no explanation, and annotations cover safety semantics. For a single-parameter read tool the description is nearly complete; only permission requirements and the meaning of 'target' remain 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?

Only one parameter (sheetId, a UUID) exists, and schema description coverage is 0%, so the description should carry meaning. It only obliquely notes the sheet must be 'accessible', which hints at a permission requirement, but the parameter name is largely self-describing, so this is adequate rather than compensating.

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 names a specific verb ('Read') and resource ('list research status and target') for a sheet, and the clause 'No research is started' implicitly contrasts it with the sibling sheets_research that does start one. The phrasing 'latest list research status and target' is a little awkward, but an agent can identify the operation.

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?

Usage is implied: check the status of an existing research run. The line 'No research is started' steers the agent away from expecting side effects and hints that sheets_research is the tool that starts work, but no alternative is named explicitly and no prerequisites are given.

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

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

Annotations already declare readOnly, idempotent and non-destructive behavior, so the safety profile is covered. The description adds useful authorization scope by stating the search only covers sheets 'currently visible to the authenticated user', which tells the agent results are permission-filtered — meaningful 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?

A single tight sentence with the method, resource, field, and scope front-loaded, and 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?

Output schema exists, so return values need not be explained, and the tool is a simple single-parameter search. However, for a search tool the description omits matching behavior, result ordering/limits, and pagination, leaving the agent to guess how results are produced.

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

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

Schema description coverage is 0% and the sole 'query' parameter has only constraints (min/max length, pattern) with no prose. The description compensates partially by naming the matched field ('title'), but says nothing about matching semantics — substring vs. exact, case sensitivity, or result limits.

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 ('Search every sheet') plus the matching field ('by title') and the scope ('currently visible to the authenticated user'). It is clearly distinct from sheets_search_rows, which searches rows rather than sheets, though it does not explicitly distinguish itself from sheets_list or workspace_search.

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 and does not mention alternatives such as sheets_list (listing) or workspace_search (cross-workspace search). The agent must infer from the name which sibling 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?

Annotations already cover the safety profile (readOnly, idempotent, not destructive, not open-world), so the description only needs to add context. It does so usefully with 'current values' (vs. history/versions), 'one accessible sheet' (scope/auth), and 'results use sheet order' (ordering behavior). It stops short of stating pagination or truncation behavior against the limit cap.

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 tight sentences: purpose first, parameter note second, alternative routing last. Zero filler, everything front-loaded and each 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?

An output schema exists, so return-value explanation is unnecessary, and the description covers scope, ordering, and the key alternative. The only meaningful gap is the undocumented limit parameter and its 25-row ceiling, which an agent would need to know to interpret results.

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 carry parameter meaning. It explains columnIds ('optional column IDs restrict the search') and implies query semantics ('text matches'), but says nothing about limit (capped at 25) or sheetId. Partial compensation for a fully undocumented 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 and resource ('Find text matches in current values of one accessible sheet') and immediately differentiates itself from the sibling sheets.query by naming it. An agent can distinguish this row-search tool from the exhaustive query tool without opening either schema.

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 routes the agent to sheets.query for 'exhaustive filters, sorting, and calculations,' giving a clear when-not condition. It does not, however, clarify when this tool is preferable to the similarly named sheets_search sibling, leaving one routing inference to the agent.

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, openWorldHint=true, and non-idempotency, so the safety profile is partly covered. The description adds the embedded-app-only access constraint, but never says which enum actions mutate or destroy data, whether calls are idempotent per action, or what the nested data payload must contain for a mutating request.

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 with no filler, and the identifying statement comes first. But the first sentence only echoes the title, so for a tool with 15 actions and a nested payload the brevity crosses into under-specification rather than efficient conciseness.

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 15 enum actions, a required UUID, a free-form nested data object, no output schema, and destructive annotations, the description leaves an agent unable to select an action or build a valid data payload. It anchors the tool's identity and access scope but is far from complete for 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% and the description says nothing about the parameters. The action enum has 15 undocumented values whose meanings (grant, pinning, enrichment_state, enrichment_review) are not derivable, and the free-form nested data object is entirely unexplained, so the description fails to compensate for 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?

"Native sheet editor requests" largely restates the title "Sheet editor transport" and never names a concrete verb or resource. An agent cannot tell what the tool actually does (it is a 15-action multiplexer for snapshot/page/grant/enrichment/view operations) nor how it differs from sheets_get, view_sheet, or the sheets_* siblings it overlaps with.

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?

"Available only to the embedded app" is a genuine access/exclusion constraint that tells an agent when this tool is off-limits. However, there is no guidance on which of the 15 actions to use, and the enum values (grant, enrichment_review, view_reorder) overlap conceptually with dedicated sibling tools, so routing is left entirely to inference.

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, so the safety profile is covered. The description adds real behavioral context beyond that: live research progress continues after the call, and the tool "works without UI as a structured result." Return shape and error behavior are not addressed, but the output schema covers returns.

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 sentences, front-loaded with what the tool shows before the call-timing and pagination details. No filler, though the pagination and UI-less notes could be tightened slightly.

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 read-only viewer with an output schema, the description covers purpose, call timing, pagination defaults, and headless behavior. It omits nothing critical, though it doesn't mention permission/access requirements implied by "accessible sheet."

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

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

Schema description coverage is 0%, so the description must compensate, and it does: cursor/direction are described as page-navigation controls with the default (omit for first page) and sheetId is tied to the sheets_research output. The direction enum values (forward/backward) are left to the schema, a minor 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 gives a specific verb ("Show") and resource ("sheet") and frames the output as an interactive table with live research progress, which separates it from plain data tools like sheets_get. It does not explicitly name a sibling it replaces, but the research-following framing makes the intent 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?

It states a concrete trigger: "Call immediately after sheets_research returns its sheetId." Pagination usage is also spelled out ("omit them to start at the first page"). It lacks explicit when-not-to-use guidance versus sheets_get or sheet_workspace, 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 readOnlyHint, idempotentHint, destructiveHint=false and closed-world scope, so the safety profile is covered. The description adds genuine behavioral context beyond that: the disclosure that row hits are 'advisory candidates, not exhaustive query results' warns the agent not to treat the output as a complete result set, which is a meaningful caveat not expressible via 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, zero filler, and the scope statement is front-loaded ahead of the caveat. Every sentence earns its place, and the second sentence carries information that changes how the agent interprets results.

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

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

An output schema exists so return values need not be described, and annotations cover the safety profile; the description adequately conveys scope plus the advisory-results caveat. However, given a dense field of near-identical search/query siblings, it omits any guidance on when this grouped search should be chosen over sheets_search or sheets_search_rows, and it leaves the per-group limit semantics 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 coverage is 50%: 'query' is documented in-schema while 'limitPerGroup' has no description. The word 'grouped' implicitly explains that the limit applies per result group (sheets, rows, docs, website), which adds some meaning over the bare integer bounds, but the description never states this relationship explicitly nor covers the query format constraints.

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

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

States a specific verb ('Discover') and enumerates the resources covered: accessible sheets, relevant rows, and public Leadbase documentation or website content. The 'in one grouped search' phrase signals it is a multi-source aggregator, which implicitly separates it from the single-source siblings like sheets_search or sheets_search_rows, but no sibling is named explicitly.

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 scope statement implies when to reach for it (cross-source discovery in a single call), but there is no explicit when-to-use, when-not-to-use, or named alternative among the many closely related siblings (sheets_search, sheets_search_rows, sheets_query, sheet_workspace). The agent must infer the routing decision.

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