PdfParse

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

Annotations cover the safety profile (readOnly, idempotent, non-destructive, openWorld), but the description adds substantial context beyond them: it requires mcp:read, sends bounded row evidence to an external model (at most 80 rows from the first 200 matches, long values shortened), and returns evidence coverage metadata and assumptions. For an open-world tool that ships data to an external model, this disclosure is exactly the value-add.

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 the 'returns in this call' guarantee are front-loaded, and each subsequent sentence carries distinct information (internal crosscheck, no extraction/save, auth and data-bounding, return metadata). It is dense but not padded; four sentences for a tool with this much behavioral surface 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?

An output schema exists, so return values need not be spelled out, yet the description still flags what matters operationally: in-call memo return, evidence coverage metadata, and assumptions. Combined with the auth requirement and external-model data limits, an agent has everything needed to call this 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 100%, so the schema already documents table_id, job_id, filters, memo_profile, and project_slug thoroughly, including job/table membership constraints. The description adds the bounded-row context but nothing per-parameter beyond the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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 ('Generates a first-pass commercial loan credit memo with citations from already extracted rows') and immediately clarifies the distinguishing boundary: it does not run or wait for extraction. Against the sibling analysis.crosscheck it also notes the crosscheck happens internally, so an agent can tell the two apart 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?

It gives clear negative guidance ('Does not run or wait for extraction or save changes') and signals that crosschecking is internal rather than a separate call, which steers agents away from misuse. It stops short of naming a specific alternative tool or the conditions where a different tool would be preferred.

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 cover safety (readOnly, idempotent, non-destructive), and the description adds material context beyond them: the mcp:read auth requirement and the external-model data egress boundary (max 80 rows from the first 200 matches, long values shortened). The data-sharing disclosure is exactly the kind of context annotations cannot convey.

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 tight sentences, front-loaded with purpose followed by the negative scope, auth/egress constraints, and return shape. No sentence is redundant or padded.

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; the description still covers scope, limits, auth, and external data handling. For a filtered read-only analysis tool, nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100%, so the schema already documents every parameter including filters, operators, and job_id semantics. The description adds no additional parameter meaning beyond the sampled-row limit implied by 'first 200 matches,' 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 (analyzes) plus resource (already extracted rows) and the exact output (findings with row and field references), scoped to 'consistency issues and underwriting risk contradictions.' This is distinguishable from siblings like rows.search (retrieval) and analysis.credit_memo (different analysis output) 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?

Clearly signals when-not: 'Does not run or wait for extraction or save changes,' steering the agent away from extraction/save tools and implying it operates only on already-extracted data. However, it never names an explicit alternative or states a positive trigger condition beyond the implicit 'there is extracted data to check.'

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 that the payload includes account identity plus a project list with IDs, names, and slugs, which is mild extra context, though much of it duplicates the output schema.

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

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

A single sentence with no filler, front-loading the primary return value (account ID) before the secondary one (projects). 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 the description need not spell out return structure, and with zero parameters and full annotation coverage there is little else an agent needs. The one residual gap is the unresolved overlap with connection.profile.

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 for the description to disambiguate. Baseline of 4 applies; no parameter-level omissions exist.

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 (Returns) and a specific resource (connected PdfParse account ID and its available projects), and enumerates the returned fields (project IDs, names, slugs). However, it never distinguishes itself from the sibling connection.profile, which plausibly covers overlapping identity data, so an agent cannot route between them from the text 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 statement, no prerequisites, and no named alternative. The only guidance is implicit: an agent might infer this is an identity/discovery call, but the presence of connection.profile as a sibling makes that inference risky.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful context beyond that: the returned ID is "stable" (does not change between calls) and "opaque" (not human-readable), which affects how an agent should store and reuse 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?

A single sentence with no filler, front-loading what the tool returns. Nothing in it is redundant with 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?

An output schema exists, so return-value documentation is not the description's job, and with zero params and full annotation coverage the surface area is small. The one remaining gap is differentiation from connection.info, which leaves the agent to guess between two similar connection 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?

The tool takes zero parameters, so there is nothing for the description to document; the baseline for a no-param tool is 4. The description adds no parameter-level information, but none is needed.

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

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

The description states a specific verb+resource ("Returns the stable, opaque ID of the connected PdfParse account") and makes the returned value's nature clear. It does not, however, distinguish itself from the sibling connection.info, which an agent could easily confuse it 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?

There is no guidance on when to call this rather than connection.info or the other connection-level tools, and no stated prerequisites or context. The agent must infer usage entirely from the name and 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds a behavioral precondition (one identifier required) but its remaining content is a listing of returned fields, which the output schema already documents.

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 behavior front-loaded and the precondition stated last. 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?

With an output schema present, the description need not explain return values, and annotations cover the safety profile, so the definition is nearly self-sufficient. The residual gap is the lack of guidance on identifier precedence and on the conditional project_slug requirement.

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

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

Schema coverage is only 33% – file_id and document_id have no schema descriptions. The description partially compensates by naming both and clarifying that document_id is numeric, plus the at-least-one rule. It says nothing about project_slug's conditional requirement or what happens if both identifiers are supplied, so the gap is only partly filled.

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 ('Returns') and resource ('a saved document') plus the accepted identifier forms, so the agent knows exactly what it fetches. It does not name or distinguish itself from any sibling, but the sibling list contains no other single-document fetch, so the ambiguity risk is low.

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 precondition ('At least one document identifier is required') but gives no guidance on when to use file_id vs document_id, or when this tool is preferable to related reads like jobs.get or rows.search. Usage is implied rather than 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 this is a non-read-only, non-destructive, closed-world write. The description adds real behavioral context beyond that: the 8 MiB decoded size cap, that a job is created immediately when tableSlug is supplied, the job/job_error failure mode, and the automatic routing/splitter fallback.

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 front-loaded sentences with no padding; the core upload action and the branch condition come first. The 'Returns document identifiers and processing details' sentence is largely redundant given an output schema exists, which is the only minor inefficiency.

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 write tool with an output schema, the description covers the important unknown: the branching behavior and size limit. The main remaining gap is routing between this tool and the near-identical sibling documents.upload_file.

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

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

Schema description coverage is only 25%, so the description must carry weight, and it does: it explains the tableSlug branch semantics and the practical size constraint on data_base64. The project_slug conditional rule is documented in the schema rather than the description, and filename is left unelaborated, which keeps this short of a 5.

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: uploads/saves a PDF from base64 bytes, and describes the two processing paths (with/without tableSlug). However, it never distinguishes itself from the sibling tool documents.upload_file, so an agent cannot tell which upload variant to pick from the description 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?

The tableSlug branch implicitly tells the caller when immediate extraction vs automatic routing happens, which is useful conditional guidance. But there is no explicit statement of when to choose this tool over documents.upload_file, and no prerequisites (auth, ownership) are mentioned.

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 safety (readOnlyHint=false, destructiveHint=false, openWorldHint=true), and the description adds genuinely non-obvious behavior: conditional job creation, the job/job_error return outcomes, fallback to project routing rules or an active splitter, and an 8 MiB size limit. It omits auth requirements for the approved host, but the added context is substantial.

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?

Five compact sentences, front-loaded with the core action and followed by the conditional behavior, return shape, and size limit. Each sentence contributes; nothing is padded or repeated.

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 detail is not required, and annotations cover the safety profile. The remaining gap is the failure to distinguish this tool from documents.upload and the unaddressed nested file object, which leaves an agent without enough to confidently choose between the two upload 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 coverage is only 33%, so the description carries extra burden. It does add real meaning for tableSlug (immediate extraction job vs. automatic project routing/splitter), but says nothing about the required file object's download_url/file_id fields, which the schema leaves undocumented.

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 and resource ('Uploads and saves a user-selected ChatGPT PDF attachment from an approved HTTPS file host'), which is concrete and actionable. However, it never distinguishes itself from the near-identically named sibling documents.upload, so an agent cannot tell which upload path to pick from the text 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?

It explains the two behavioral branches ('With tableSlug... Without tableSlug...'), which is useful routing context, but it never states when to choose this tool over documents.upload or any other sibling. Usage is implied through parameter behavior rather than explicitly 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, non-destructive, and closed-world, so the safety profile needs no restating. The description adds the useful scoping constraint that results are limited to owned projects, but says nothing about result volume, pagination, 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?

A single front-loaded sentence that states scope first and payload second, with no filler. Nothing would be lost by keeping it exactly as is.

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-optional-parameter list tool with a full output schema and rich annotations, the description covers purpose, scope, and return contents adequately. Slightly more on the zero-project edge case or result size would make it complete, but no essential calling information is missing.

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

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

Schema coverage is 100%, so the project_slug conditionality is fully documented in the schema. The description reinforces the 'owned project' restriction, which is marginal added value over the structured field — 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?

The description gives a specific verb (Lists) and resource (email inboxes) plus scope (owned projects) and the returned fields (IDs, addresses, names). It is unambiguous, though it does not name a sibling or alternative — there is no other inbox tool among the siblings to distinguish it from, so the omission is minor.

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: an agent can infer this is the read path for enumerating inboxes before using routing rules or analysis tools. However, it never states when to call this versus other discovery tools, nor does it mention the single-project shortcut case beyond what the schema says.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the mutation and safety profile is covered. The description adds the prerequisite that documents must already be uploaded, which is helpful context, but says nothing about the async/job nature of the operation or what happens on re-runs.

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, so it is efficiently sized. It is arguably too terse for a job-creating mutation, but conciseness itself is well executed.

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, but for a non-read-only job-creation tool with only 33% parameter coverage the description is thin: it omits what the job does, whether it is asynchronous, and how documentKeys are supplied. It leaves the agent with meaningful gaps.

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

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

Schema description coverage is only 33%, so only project_slug is documented in the schema. The description gestures at tableSlug and documentKeys via 'documents already uploaded to a table' but adds no format, identifier, or batching semantics to compensate for the uncovered parameters.

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

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

The description names a specific verb ('Start extraction') and resource ('documents already uploaded to a table'), so the agent knows this kicks off processing rather than retrieving results. The phrase 'already uploaded' implicitly distinguishes it from documents.upload, but it does not explicitly contrast with jobs.get or other extraction 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?

The phrase 'documents already uploaded' implies the prerequisite that documents must exist before calling, which is a useful usage cue. However, there is no explicit when-to-use/when-not-to-use guidance or mention of the alternative jobs.get for checking status.

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 behavior, so the safety profile is covered. The description adds the ownership scoping constraint, but says nothing about error behavior for missing or unauthorized jobs, or pagination (not applicable for a single get).

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 the key scope constraint ('owned project') front-loaded. There is no wasted text, though brevity comes at the cost of detail.

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

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

An output schema exists, so return values needn't be described. However, with an undocumented job_id parameter and no usage guidance, the definition is only minimally sufficient for an agent 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 coverage is 50%: project_slug is fully documented in the schema, while job_id is only typed as an integer with no description. The description does not compensate by explaining what a job_id is or how to obtain it. Baseline 3 is appropriate given partial schema coverage.

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

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

States a specific verb ('Returns') and resource ('an extraction job'), scoped to an owned project. It distinguishes itself from write siblings like jobs.create, though it doesn't mention relationships to splitters.run or documents tools that generate jobs.

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 alternatives such as listing or inspecting job output through other tools. The 'owned project' scope is implied but exclusions or prerequisites are 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=false, destructiveHint=false, and openWorldHint=false, so the write-but-non-destructive profile is covered structurally. The description adds genuinely useful context that the created project is 'empty' (no tables/workflow included) and that the ID and slug are the outputs. It omits permissions/auth requirements, whether the name must be unique, and what happens on a duplicate name.

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 zero filler, and the core action is front-loaded before the return-value note. 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?

An output schema exists, so explaining return values is optional (and briefly done anyway), and annotations cover the mutation safety profile. The remaining gap is the undocumented 'name' parameter and the absence of any note on duplicate names or permissions, which matters for a create tool with 0% schema coverage.

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 the single 'name' parameter, so the schema supplies only type and length bounds (2-100) with no semantic guidance. The description never mentions the name argument, its uniqueness, or any naming constraints, so it 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?

States a specific verb and resource ('Create an empty project') plus the account scope, which is more than a tautology. It also situates the tool relative to downstream objects ('table and workflow setup'), though it never names a sibling tool it must be chosen over.

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 'for subsequent table and workflow setup' implies this is the prerequisite step before tables.create and workflow.setup, which gives the agent sequencing context. However, there is no explicit when-to-use statement, no when-not condition, and no named alternative, so the guidance remains inferred.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the mutation and safety profile is covered. The description adds a meaningful domain constraint (the target table must belong to this project) but says nothing about duplicate-rule behavior, permissions, or what happens to existing rules.

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 tight sentences, front-loaded with the core action and followed by the critical scoping constraint. No padding, though the second sentence could carry a bit more payload given the low schema coverage.

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 mutation tool with six parameters at 17% schema coverage and no alternative-tool guidance, the description is only minimally 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?

Schema description coverage is only 17% (just project_slug), so the description should compensate but largely does not. It maps loosely onto prompt ('recognizes a document type') and tableId ('extraction table'), but name, enabled, and confidenceThreshold are left entirely undocumented in both schema and description.

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

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

The description states a specific verb ('Create') and resource ('rule') plus the rule's function (recognizes a document type, routes to an extraction table). It is clearly distinguishable from routing_rules.update/delete/list by the verb, but it does not name or contrast those siblings 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?

Usage is only implied by the verb 'Create'; there is no explicit when-to-use, no when-not, and no mention of routing_rules.update as the alternative for modifying existing rules. The one constraint given ('table must belong to this project') is a prerequisite rather than usage routing.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is covered, but the description adds nothing beyond that: no statement that deletion is permanent/irreversible, whether dependent rules or artifacts are affected, or what permissions are required. For a destructive mutation, 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 front-loaded sentence with no padding, which is structurally clean, but it is bare to the point of under-specification for a destructive operation rather than optimally concise.

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, but for a destructive two-parameter tool the description omits the confirmation/irreversibility behavior, permission requirements, and the project_slug disambiguation that an agent needs before invoking 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 50%: project_slug is documented in the schema (including its single-project optionality), but rule_id has no description at all. The prose only obliquely implies 'a routing rule' and 'a project' and never clarifies the id format or the project scoping rule, so it fails to compensate for the uncovered parameter.

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

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

The description states a specific verb and resource ("Delete a routing rule") and scopes it to a project, which cleanly separates it from routing_rules.create, routing_rules.update, and routing_rules.list. It stops short of any explicit sibling routing language, but the purpose 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 versus routing_rules.update (e.g., disabling vs. removing) or any prerequisites such as ownership of the rule/project. The only usage hint is the implicit 'from a project' scoping, which is inferred rather than 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=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds only that destination tables are included in the result, with no notes on permissions, project visibility, or pagination.

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. Every word earns its place and there is 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?

An output schema exists, so return values need not be explained, and annotations carry the safety profile; the parameter is fully documented. For a simple read-only list tool the description is nearly sufficient, losing a point only for absent usage routing.

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% and the single project_slug parameter is thoroughly documented in the schema, including its conditional optionality. The description's 'in a project' phrase adds nothing beyond that, so the 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 (List) and resource (document classification rules) plus a useful qualifier (their destination tables). This distinguishes it from routing_rules.create/update/delete, though it never names those siblings 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?

Usage is implied by 'List' — call it to inspect existing rules — but there is no explicit when-to-use guidance, no mention of prerequisites, and no routing to sibling tools such as routing_rules.create when rules are missing.

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 declare destructiveHint=true and readOnlyHint=false, but the description does not explain whether this is a partial or full replacement update, whether omitted fields are preserved or cleared, or that the operation is destructive. For a destructive mutation, the partial-vs-replace semantics are the single most important thing to disclose and they are absent.

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

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

One tight sentence, front-loaded with the action and resource, with no redundant restatement of the title. Efficient, though brevity here is partly a symptom of missing content rather than disciplined trimming.

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, but with 14% schema coverage, destructive mutation semantics, and no usage guidance, the definition leaves critical information an agent needs before calling this tool.

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

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

Schema description coverage is only 14%, so the burden falls on the description, yet it covers just three of seven parameters (prompt, confidenceThreshold, enabled) and omits rule_id, name, tableId, and project_slug. It adds no format or constraint detail (e.g., the 60-100 confidence range) beyond what the schema already encodes.

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 (change) and resource (routing rule) and enumerates the mutable fields, so it is distinguishable from routing_rules.create/delete/list at a glance. However it names 'destination' while the schema exposes 'tableId', leaving a small ambiguity about what is being changed.

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, no mention of when to prefer routing_rules.create or delete, and no prerequisites such as required permissions or project scoping are given. The agent is left to infer invocation context entirely.

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, so the safety profile is fully covered and the bar is lower. The description adds genuine context that results are paginated and scoped to an owned project, but says nothing about defaults, page-size ceilings, ordering when unspecified, or error behavior for unknown columns.

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

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

A single sentence, front-loaded with the return value and scoped by project, with zero filler. Nothing could be removed 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-shape explanation is unnecessary, and annotations cover safety. But for a six-parameter tool with nested filter objects and low schema coverage, the description is too thin on parameter and usage context to be fully self-sufficient.

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

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

Schema description coverage is only 33%, so the description is expected to compensate, and it does not: it mentions filters and ordering only generically. Page, pageSize, and the orderBy sub-fields have no prose anywhere, and the filter semantics an agent needs are carried entirely by the nested schema descriptions.

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

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

States a specific verb and resource ('Returns paginated extracted rows from a table') plus scope ('in an owned project') and the two modulating capabilities (filters, ordering). It is clear and non-tautological, though it never names or contrasts a sibling such as tables.list.

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

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

Offers no when-to-use guidance, no prerequisites, and no alternatives. An agent gets no signal on when rows.search is the right call versus tables.list or the documents tools; the project-ownership precondition is left entirely to the schema.

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, readOnlyHint=false, and openWorldHint=false, so the safety profile is covered. The description adds the behavioral consequence that archiving stops future use, but doesn't explain reversibility, required permissions, or side effects beyond that, leaving gaps for a destructive mutation.

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

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

A single, front-loaded sentence that states the action and effect with no wasted words. It is appropriately sized for the tool's simplicity.

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 needn't be explained. However, for a destructive mutation with only two parameters and partial schema coverage, the description should clarify irreversibility, permission requirements, or the fate of existing documents; it leaves these behavioral aspects 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?

Schema coverage is 50%. The description adds no meaning for splitter_id or project_slug; it only mentions 'a splitter' generically. The project_slug schema description already explains its conditional requirement, so the description doesn't compensate for the uncovered splitter_id.

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 'archive' and resource 'splitter', with the effect stated ('stop using it for future documents'). It distinguishes itself from siblings like splitters.update_logical or splitters.publish, though it doesn't explicitly name the alternative sibling to use for deactivation.

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?

Implies usage when a splitter should no longer be used, but provides no explicit when/when-not guidance, prerequisites, or alternatives (e.g., when to archive vs update or delete). The context is clear but not directive.

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 establish readOnlyHint=false and destructiveHint=false. The description adds genuinely non-structured lifecycle context: the result is an inactive draft, it does not take effect until publication, and routing uses project routing rules. This is real behavioral value 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?

Four tight sentences, front-loaded with the core action and result state. No filler; the inbox-binding and publication facts each carry 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 explained, and lifecycle/routing are covered. But for a tool with a deeply nested config and low schema coverage, the description omits how the sectionTypes/instructions config should be shaped, which 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 only 25% and there are 4 params (one deeply nested with ~8 sub-fields). The description explains sourceInboxId (null vs inbox binding) usefully, but leaves mode, instructions, sectionTypes, maxSegments, thresholds, and config structure undocumented in both schema and description. Partial compensation for a large 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?

States a specific verb and resource ('Creates an inactive logical splitter draft') with a clear scope qualifier ('for mixed PDF attachments'). This distinguishes it from sibling splitters.create_page_range, which handles page-range splitting rather than logical section splitting.

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

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

Provides useful context: sourceInboxId binding vs null for project uploads, project routing rules, and that the draft only activates after publication. However, it never explicitly says when to choose this over create_page_range or update_logical, leaving alternative selection 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 readOnlyHint=false and destructiveHint=false, so the safety profile is covered. The description usefully adds that output is a 'draft' (not published or executed) and that destination tables are 'project-owned', but says nothing about overlap/unassigned policies or what happens if the config is invalid.

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 appropriately tight, though its brevity is more a function of under-specification than disciplined economy.

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

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

For a tool with nested objects, low schema coverage, and multiple policy enums, the description is far too thin. It omits the draft lifecycle, the project_slug account constraint, and any explanation of the config policies, leaving the agent under-equipped despite the output 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 only 25% (only project_slug is documented). The description gestures at 'page ranges' and 'destination tables' but leaves the nested config fields (mode, sections, overlap_policy, unassigned_policy, max_segments, fallback_section_key) unexplained, so it does not 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?

States a specific verb ('Create') and resource ('splitter draft') plus the distinguishing trait ('fixed page ranges', project-owned destination tables), which separates it from the logical-mode sibling. It does not explicitly name create_logical or update_page_range, but the page-range facet is clear enough to identify the 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives like splitters.create_logical or splitters.update_page_range. The 'draft' wording hints at lifecycle stage but leaves the choice among sibling splitters tools 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 readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds real context that the response bundles a draft with its published versions, but says nothing about error behavior (e.g. unknown splitter_id) or access scope. With annotations present, a 3 fits.

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 result front-loaded and zero filler. It is efficient, though arguably under-specified rather than concise.

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 annotations cover the safety profile. What is missing is usage routing relative to splitters.list and any note on the project_slug conditionality, which leaves the definition only barely sufficient for a read tool.

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

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

Schema description coverage is 50%: project_slug is documented in the schema with its conditional requirement, while splitter_id is undocumented there and receives no explanation in the description either. The description adds no parameter meaning at all, so it 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?

Specific verb (returns) plus resource (a splitter draft and its published versions), which is clearer than a bare 'get'. It does not, however, distinguish itself from the sibling splitters.list or explain the draft/version relationship.

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 splitters.list for enumeration or splitters.update_* for mutation. The agent must infer the tool's role 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.

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 genuine value by disclosing that drafts as well as published versions are returned, but says nothing about pagination or result volume.

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

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

A single sentence with zero filler, front-loaded with the verb and resource and ending with the scoping qualifier. Nothing in it is redundant.

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 carry the safety profile. The description covers what is listed and where, leaving only minor gaps around result size or ordering.

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 exists and schema description coverage is 100%, so the schema already explains the project_slug optionality rule in detail. The description's 'in a project' adds no syntax or meaning beyond that, matching the baseline of 3 for high-coverage schemas.

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 (splitters) and adds scope detail — page-range and logical types, plus drafts and published versions. It does not explicitly distinguish itself from splitters.get or the create/update siblings, so it stops short of 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?

Usage is only implied by the verb 'List' and the 'in a project' scoping. There is no explicit when-to-use statement and no mention of alternatives such as splitters.get for a single splitter, so the agent must infer the selection 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=false and destructiveHint=true, so the mutation risk is covered; the description adds the useful outcome that the splitter becomes live for the source inbox/project uploads. However, it never explains the destructive implication the annotation hints at — whether publishing replaces an already-active splitter — nor permission or concurrency 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?

Two short sentences with the action verb front-loaded and zero filler. It is efficient, though the brevity comes at the cost of the context a destructive publish tool needs.

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, non-read-only publish operation with a required revision guard, the description omits key agent-relevant facts: what happens to a currently active splitter, how a revision mismatch is handled, and the project_slug scoping caveat that the schema notes. The existence of an output schema excuses omitting return values, but not these gaps.

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

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

Schema description coverage is only 33% (project_slug is documented in the schema; splitter_id and expected_draft_revision are not), and the description adds nothing about any of the three. Most critically, expected_draft_revision is a required optimistic-concurrency token whose meaning and failure mode are left entirely 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?

States a specific verb+resource (publish a splitter draft) and clarifies the resulting state change: the logical splitter becomes active for its source inbox or project uploads. This distinguishes it reasonably from siblings like splitters.create_logical, splitters.update_logical, and splitters.archive, though it never names an alternative directly.

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

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

The description implies a lifecycle position (draft → active) but gives no explicit when-to-use guidance, no prerequisites (a draft must exist and its revision must be known), and no when-not guidance relative to splitters.update_logical or splitters.archive. An agent must infer the workflow entirely.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=false and destructiveHint=false, so the agent knows this is a non-destructive local-side-effect operation. The description adds almost nothing beyond that: it doesn't say whether the run is synchronous or job-based, whether it writes output to the project, or whether the document is modified. With annotations carrying the safety profile, this still leaves meaningful behavioral gaps.

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 zero redundant or filler text; the action and target come first. It is appropriately sized for a one-line description, though the brevity borders on under-specification rather than wasteful padding.

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

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

An output schema exists, so return values need not be explained. But for a write-flagged operation with 4 parameters (two required) and a 25% documented schema, the description omits prerequisites (publishing/version), execution model (async job vs. inline result), and effect on the document or project — leaving an agent unable to invoke it confidently.

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

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

Schema coverage is only 25% (only project_slug is documented), and the description supplies no parameter meaning at all — it doesn't explain splitter_id, document_id, or version (e.g., which splitter version is targeted). 'In this project' only loosely gestures at project scoping and does not 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?

States a specific verb ('Run') and resource ('published fixed page-range splitter on a document'), which lets an agent distinguish it from splitters.test_page_range and splitters.create_page_range by the 'published' qualifier. However, it never names the sibling tools or explicitly contrasts running vs. testing vs. creating, so differentiation is inferred rather than stated.

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, no prerequisites, and no alternatives are given. The word 'published' hints that a splitter must be published first (via splitters.publish), but this precondition is never stated, nor is it explained when to use this versus test_page_range.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe, repeatable read preview. The description adds the key behavioral detail that nothing is saved. It does not explain whether preview results reflect unsaved changes to the splitter, whether the page_count parameter can differ from the splitter's stored configuration, or any rate limits. Given annotations cover safety, a 3 is appropriate.

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 tight sentence, front-loaded with the verb and the key differentiator (no save). 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?

The output schema exists, so return values need not be explained. But with four parameters and only 25% schema coverage, the definition is not complete enough for an agent to know what page_count or version control in a preview. Annotations cover the safety profile, but parameter semantics remain under-specified.

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

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

Schema description coverage is only 25%: only project_slug has a description. The description itself mentions no parameters, so splitter_id, page_count, and version are undocumented beyond their types. page_count is critical to a page-range preview and its meaning is not clarified in either place, which is a real gap.

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

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

The description states a specific verb (preview) and resource (page assignments and review flags for a page-range splitter), and distinguishes itself from the sibling run_page_range by saying "without saving a run." However, it doesn't name siblings directly, and the purpose is clear enough to select 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?

Implied usage: preview before running, since it says "without saving a run." No explicit when-to-use versus splitters.run_page_range or splitters.create_page_range, and no prerequisites like needing an existing splitter_id. The contrast with saving a run is useful but not a full routing guideline.

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 this is a non-read-only, destructive mutation, so the safety profile is covered. The description adds genuinely useful context beyond that: the optimistic-concurrency requirement that expected_draft_revision must match the current revision. It still omits whether this operates only on drafts, permission requirements, and what the update overwrites.

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 tight, front-loaded sentences with no waste, and the concurrency constraint is stated directly. It is efficient, though sentence two could have absorbed a bit more of the config semantics at little cost.

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, but the tool has 6 parameters with a deeply nested config object and a 17% coverage schema. The description leaves the entire config structure, the mode constraint, and the draft-only scope unexplained, which is inadequate 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 only 17%, so the description must carry the burden, but it only explains expected_draft_revision (the concurrency check). The complex nested config (mode const "logical", sectionTypes, routingMode, thresholds), name, description, and splitter_id receive no explanation in the description.

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

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

The description states a specific verb and resource ("Updates a logical splitter draft"), and the word "logical" implicitly separates it from the sibling update_page_range. It is clear, though it never explicitly names that sibling or what distinguishes the two flows.

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 versus splitters.create_logical, splitters.publish, or splitters.update_page_range, and no mention of the draft-vs-published workflow. The agent must infer all routing 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.

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

Annotations already declare readOnlyHint=false and destructiveHint=true, so the write/destructive profile is covered. The description adds one genuine behavioral nugget: the update is bound to the 'current draft revision', implying optimistic-concurrency semantics around expected_draft_revision. It still omits what the update destroys (prior draft config) and any published-state constraints.

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

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

A single tight sentence with the verb and resource front-loaded and no filler. It is arguably under-specified rather than over-specified, but structurally it is clean.

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, but for a 6-parameter tool with a deep nested config object and destructive semantics, the description leaves the agent without the field-level or workflow context needed to call it correctly.

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

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

Schema description coverage is only 17%, so the description must carry the burden and it does not: name, config (nested sections/page_spans/policies), description, and splitter_id are never mentioned. Only expected_draft_revision is semantically touched on via 'current draft revision'.

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) and a specific resource (fixed page-range splitter draft), which distinguishes it from the logical-splitter sibling splitters.update_logical. It does not, however, explicitly name that sibling or explain the contrast beyond the wording.

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: nothing says when to edit a draft vs. splitters.create_page_range, splitters.publish, or splitters.update_logical, nor any prerequisite about the splitter needing to be an existing draft. Usage must be inferred entirely.

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 this is a non-read-only, non-destructive, non-open-world operation. The description adds useful behavioral context beyond that: an integer primary key 'id' is auto-added and generated during extraction, which is a real implementation detail an agent could not infer. It does not cover failure modes or what happens to columns on re-analysis, so credit is moderate.

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 tight sentences, front-loaded with the core action before the auto-key detail. No filler, though the auto-key sentence could arguably be consolidated.

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. However, the rich nested columns schema and the project_slug conditional rule are under-explained, 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 33%, so the description must compensate, but it only loosely gestures at 'extraction columns' without explaining the column objects (prompt, type, foreign_key, unique, nullable, etc.). Only project_slug carries a schema description, leaving name and columns undocumented 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 ('Creates') and resource ('a table with extraction columns') scoped to 'an owned project'. It is clearly distinguishable from the sibling tables.list, though it does not name 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 guidance on when to use this tool versus alternatives, nor any stated prerequisites such as required permissions or the project_slug multiplicity rule. The 'owned project' phrase implies scope but does not direct 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, idempotentHint, destructiveHint=false and closed-world behavior, so the safety profile is fully carried by structured data. The description adds only the note that extraction columns are included in the result, which is modest added context beyond annotations. No pagination, ordering, or scope-limit behavior is disclosed.

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

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

Two tight sentences, with the core purpose front-loaded and no filler. The second sentence largely restates the schema's own parameter description, which slightly weakens the claim that 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?

Complexity is minimal: one optional string parameter, an output schema that defines the return shape, and annotations that cover safety semantics. Purpose plus the scoping condition for project_slug is sufficient for an agent to call this correctly without further description.

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

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

Schema description coverage is 100% and the schema's project_slug description already spells out the same 'optional only when exactly one visible project' rule nearly verbatim. The description therefore adds no meaning beyond the schema, matching the baseline of 3 for a single well-documented 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?

States a specific verb (Lists) and resource (tables) scoped to an owned project, and adds what the result contains (extraction columns). This is unmistakably distinct from the write-oriented sibling tables.create and from the splitters.* family.

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 a conditional rule for project_slug (required when multiple projects are visible), but this is a parameter condition rather than tool-selection guidance. It never says when to prefer this tool over alternatives such as rows.search or splitters.list, so usage is only implied by the verb.

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=false, destructive=false, idempotent=true, and openWorld=false, but the description goes further: it discloses the mcp:write permission requirement, the exact validation surface of dry_run (ownership, table-name collisions, splitter conflicts), that blocked previews return blockers, and that repeating the same intent resumes saved progress. That last point independently corroborates the idempotentHint with concrete mechanism.

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 dense sentences, purpose front-loaded, with dry_run behavior and auth requirement following in priority order. No filler, though the final sentence about resume behavior could be folded into the dry_run discussion for tighter flow.

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 7-parameter composite mutation tool with nested objects, the description covers safety profile, preview semantics, auth, and repeat-invocation behavior, and an output schema exists so return values need no explanation. The remaining gap is the absence of routing guidance relative to the individual create/publish sibling 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 100%, so every parameter including nested objects is already documented in the schema; the description adds no syntax, format, or constraint detail beyond what is there. Baseline 3 is correct when the schema does the heavy lifting.

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 ('Provisions') and enumerates the exact resources created (table, routing rule, optional inbox, published logical splitter), so the composite nature of the operation is clear. It does not explicitly name the sibling tools (tables.create, routing_rules.create, splitters.create_logical) it bundles, leaving the agent to infer that this is the one-shot alternative.

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 clear operational context: must be an existing owned project, both preview and apply require mcp:write, and dry_run:true is the preview path. However, it never states when to prefer this composite tool over calling the individual sibling tools, which is the most likely routing decision an agent faces.

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