Corply — Start and run your company

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

Annotations give readOnlyHint=false, openWorldHint=true, destructiveHint=false, so the safety profile is partly covered. The description adds real behavioral context beyond that: canonicality (trust the returned actual_tool_output rather than making a state-recovery call), idempotency/retry guidance, and an explicit confirmation boundary. It is generic template language rather than tool-specific detail, so it earns a 3.

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

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

The purpose is front-loaded in the first sentence, which is good, but the remainder is compressed jargon ('Canonicality', 'Idempotency', 'Confirmation boundary') plus a dangling 'every prerequisite stated above' clause that adds no usable information. Dense but not wasteful per se; the structured labeling is somewhat helpful.

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 3 parameters, a nested object, no output schema, and 0% schema description coverage, the description should carry more weight. It covers the url rules and retry/confirmation behavior, but omits any explanation of intakeId, _corply_context, or what the returned actual_tool_output contains. The dangling prerequisite reference further weakens completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It does add meaningful constraints for url (public, HTTPS, PDF, up to 25 MB) that the bare 'format: uri' schema lacks. However, it says nothing about intakeId's role or the nested _corply_context object, leaving two of three parameters 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 opening sentence states a specific verb (Add), resource (founder-provided public HTTPS PDF link) and target (a document dump), which is concrete enough to act on. It does not, however, distinguish itself from close siblings like upload_company_import_document (file upload) or create_company_import_upload_link, and 'document dump' is an informal term for what is presumably an import intake.

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 only usage guidance is 'Prerequisite: authenticated active company access plus every prerequisite stated above,' but nothing is 'stated above' in this description, making the reference dangling boilerplate. There is no explicit when-to-use, and no comparison against the sibling upload/link-creation tools that an agent must choose between.

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

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

Annotations only declare readOnly=false, destructive=false, openWorld=false; the description adds substantial context beyond that—records are founder assertions not verified facts, a refreshed get_company_briefing result is returned, charter/bylaws/cap table are requested when available, and it explicitly does not file, pay, sign, invite, or verify. Idempotency and retry semantics (same key returns original result; different inputs rejected) are also disclosed.

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

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

The core content is front-loaded, but the block is bloated with generic-sounding boilerplate (Canonicality, Idempotency, Confirmation boundary) and a duplicate prerequisite statement ('Prerequisites: ...' followed later by 'Prerequisite: authenticated active company access plus every prerequisite stated above'). Some sentences do not earn their place.

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

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

For an eight-parameter, no-output-schema write tool, the definition covers prerequisites, idempotency, return behavior, and the confirmation boundary, so an agent has enough to call it correctly. The unresolved gap is the identity/linking parameters (companyId, _corply_context) that the description never ties to the action.

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 maps the semantic fields (name, jurisdiction, entity type, date, file number) to the assertedName/jurisdiction/entityType/formationDate/fileNumber parameters and highlights idempotencyKey's role, but companyId and the nested _corply_context object are never explained, leaving two of eight parameters unaddressed.

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: it attaches an already-existing company without creating a Corply formation, and enumerates what gets recorded (name, jurisdiction, entity type, date, file number). It also explicitly distinguishes itself from the sibling import_company by naming the alternate workflow, so an agent can route 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?

The first sentence names the alternative (import_company) and the condition that selects it (document-by-document import and missing-service workflow). It also lists prerequisites (active company-manager access, connected company, stable idempotencyKey), leaving little 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 non-read-only, non-destructive, and closed-world behavior, but the description adds substantial context: database-enforced gates, consent/payment/approval recording requirements, prohibitions on signing/filing/charging/cap-table mutation, and idempotency/retry guidance. It gives the agent enough behavioral context to avoid false state claims.

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 purpose is front-loaded and the dense detail reflects real complexity. However, it also contains generic canonicality, idempotency, and confirmation-boundary boilerplate that is longer than necessary and includes 'this read' despite being a state-mutating 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?

For a complex mutation with seven parameters, no output schema, and 0% schema coverage, the description covers many behavioral and prerequisite concerns. It still leaves key parameter semantics and return-value handling largely unexplained, so it is adequate but not complete.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It clarifies expectedStatus as the current status and idempotencyKey as a stable retry key, but omits the target nextStatus semantics, reason, caseId/companyId expectations, and the nested _corply_context object.

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, and mechanism: advance one corporate action case through an explicit durable state graph. This clearly distinguishes it from create/get/list corporate action siblings by focusing on controlled state transition.

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?

Explains when to use it: after the stated human action actually occurred, with the exact expectedStatus and a stable idempotency key, plus prerequisite authenticated access and kind-specific gates. It does not explicitly name alternative tools or when-not-to-use cases, keeping it 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 flag destructiveHint=true, but the description goes well beyond them by naming exactly what is destroyed or invalidated: the frozen legal documents and open signature requests, plus intake reopening and the need for document regeneration and fresh signatures. It also adds retry/idempotency and state-recovery guidance ('inspect refreshed state before retrying') that no annotation conveys.

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 key consequence and confirmation gate are front-loaded, which is good. But the tail is padded with near-boilerplate that adds little ('authenticated active company access plus every prerequisite stated above' is circular, and the canonicality/idempotency paragraphs read as template text), diluting an otherwise strong opening.

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

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

For a complex, deeply nested mutation with no output schema, the description covers the important ground: side effects, confirmation gate, prerequisite access, retry posture, and the returned shape (standardConfiguration with canonical nextStep). The main remaining hole is the unexplained revision/hash guard parameters.

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

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

Schema description coverage is low (20%), so the description must carry the load, and it does add one important semantic: 'Partial data still deep-merges over stored answers,' clarifying that `data` is a merge rather than a full replacement. However, the required `expectedRevisionId` and `expectedDataHash` concurrency/optimistic-lock parameters get no explanation anywhere, leaving a meaningful 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 and resource ('Apply confirmed answer changes to a frozen, pre-submission formation') and the 'frozen, pre-submission' framing implicitly separates it from draft-oriented siblings like save_application or validate_application. It stops short of naming an alternative, so the differentiation is inferred rather than 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?

'Use only after the founder explicitly confirms that consequence' gives a clear activation condition, reinforced by the explicit 'Confirmation boundary: obtain fresh, explicit user confirmation before calling.' It does not, however, route the agent away from adjacent tools (save_application, propose_formation_change, decide_formation_change) when the application is not frozen.

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

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

Annotations only disclose readOnlyHint=false, destructiveHint=false, openWorldHint=true, so the description carries most of the burden and does well: documents stay pending until admin acceptance, screening is not verification, never pay or sign, idempotency/retry and confirmation-boundary rules. The generic canonicality/idempotency/confirmation boilerplate is somewhat mechanical, keeping this from a 5.

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 instruction is front-loaded, but the description runs long and is padded with boilerplate canon (canonicality, idempotency, confirmation boundary) that reads as generic appended text rather than earning its place. The logo/email-domain follow-up steps are crammed in, making it harder to scan for the primary action.

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

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

For a complex tool with a nested schema, no output schema, and no rich annotations, the description covers prerequisites, pending-state behavior, idempotency, confirmation boundaries, and downstream follow-ups. It is broadly complete, with only the parameter-level detail (companyId, quantity, enum meanings) left thin.

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

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

Schema description coverage is 0%, so the description must compensate. It conveys the meaning of the choices array (existing documents vs services Corply should perform, mapping loosely to have/corply/not_applicable) and implies itemKey semantics via the asked questions, but never explains companyId, the enum values explicitly, or the quantity field.

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

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

The opening sentence states a specific verb (save) and resource (the founder's multiple-choice answers for company documents/missing services), which is concrete and actionable. It does not, however, differentiate itself from close siblings like confirm_import_intake, create_import_intake, or answer flows, so the agent must infer placement from the fleeter enum names. Clear but not fully disambiguated.

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 concrete operating guidance: ask one question at a time, never assume documents, offer the HTTPS PDF import, and the prerequisite of authenticated active company access. It never names a sibling alternative or says when NOT to use it (e.g., vs the confirm/get import tools), so it stops short of full routing guidance.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, and the description adds substantial context beyond them: it cannot act on behalf of another person, it does not sign documents, it names canonicality (trust returned actual_tool_output instead of a state-recovery call), and it gives idempotency/retry guidance. For a destructive write this is unusually complete disclosure.

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

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

The key behavioral rules are front-loaded, but the trailing Canonicality/Idempotency/Confirmation boundary block reads as generic boilerplate that could apply to many tools and dilutes the tool-specific content. It is information-dense rather than padded, but the template-like tail costs structure points.

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

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

The description is strong on process, consent, and safety, which suits a destructive mutation with no output schema. What it omits is the shape of the nested identity payload it is expected to save: which fields are required, how address should be collected, and how the tax/immigration fields relate to the disclosure. For a tool whose only output is a saved identity object, that gap is notable.

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

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

With schema description coverage reported at 0% for the top level, the description must carry the burden, and it only partially does. It clarifies that identity.name is the full legal name as on government ID and that consent means explicit plain-text agreement rather than a choice option, which is genuinely useful. However, joinCode, address, usTaxpayer, usCitizenOrPermanentResident, immigrationStatus, and f1WorkAuthorization receive no explanation, leaving a nested required object largely undocumented in prose.

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

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

The description states a specific action on a specific resource: show the invitee the disclosure from review_invited_identity and then save their own approved identity details. It positions itself relative to redeem_invite (prerequisite) and review_invited_identity (the read-only counterpart), so an agent can distinguish it from those siblings. The core verb is somewhat embedded in process narration rather than stated up front, which keeps it 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?

Explicit sequencing is given: use after redeem_invite and after showing the exact disclosure from review_invited_identity, and only once the invitee gives explicit agreement as a plain-text reply rather than a choice option. It states prerequisites (authenticated active company access plus prior steps) and an explicit confirmation boundary before calling. Nothing about when to invoke is left 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 declare readOnlyHint=false and destructiveHint=false; the description adds useful context that this is a manager action, that the mailbox works over IMAP/SMTP inside and outside Corply, and that only the address's own person can read/send. Much of the remainder is generic boilerplate (canonicality, idempotency, confirmation-boundary templates) that describes policy classes rather than this specific mutation's effects.

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 actionable content (assign an inbox, confirm first) is correctly front-loaded, but the definition then pads with long reusable policy sentences on canonicality, idempotency and confirmation boundaries that are not specific to this tool and dilute the signal.

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

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

For a two-required-parameter mutation with no output schema and no parameter descriptions, the definition covers prerequisites and the founder-confirmation gate but omits what the call actually returns/changes and how to obtain a valid memberUserId. It is adequate but leaves real gaps 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 low (33%): localPart is documented in the schema itself ('The part before @, such as jane.') and memberUserId carries no description at all. The description repeats the jane@acme.com example but never explains how to resolve memberUserId (e.g., via a roster/lookup call) or what _corply_context is for, 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?

The first sentence states a specific verb and resource ('Give a company member an inbox') and marks the actor class ('a manager action'), so the agent knows this assigns an address rather than listing (list_company_inboxes) or enabling the domain (enable_company_inboxes). It stops short of explicitly naming the sibling it is not, so it is clear but not fully 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?

It gives a prerequisite (authenticated active company access) and a procedural precondition ('Confirm the member and the address with the founder first'), which implies when to use it. However it never names the alternative tools (enable_company_inboxes, update_email_sender, connect_email_domain) or states when NOT to assign an inbox, so routing rests on 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 only declare readOnlyHint=false, destructiveHint=false, openWorldHint=false. The description goes well beyond that: append-only/immutable semantics, explicit non-claims about downstream approval/signature/filing/payment/ledger/cap-table effects, a hard prohibition on secrets and tax IDs in metadata, canonicality guidance to trust the returned actual_tool_output rather than issuing a state-recovery call, and idempotency 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?

Purpose and non-claims are front-loaded and dense with real content, but the back half is template scaffolding ('every prerequisite stated above', 'obey the tool-specific retry key or guarantee; if none is stated...', the long confirmation-boundary list) that reads as boilerplate rather than tool-specific guidance.

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 9-parameter, 8-required mutation with nested objects, no output schema, and 0% schema description coverage, the definition is strong on safety posture but leaves parameter semantics undocumented and leans on internal jargon ('actual_tool_output and context_engineering', 'state-recovery call') that the agent may not resolve.

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% across 9 parameters (8 required), so the schema provides no prose semantics. The description compensates only indirectly: 'hash-backed' gestures at contentHash and the metadata prohibition constrains that parameter, and idempotencyKey gets retry guidance—but caseId, evidenceType enum values, reference, and title are never explained.

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 precise verb+resource+scope: 'append hash-backed evidence to one exact company-scoped corporate-action case.' It also defines the boundary of the write ('immutable reference only; it does not claim the underlying approval... occurred'), which separates it from siblings such as record_operating_evidence, submit_operating_fact_evidence, and upload_operating_evidence.

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

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

Gives prerequisites (authenticated active company access plus upstream prerequisites), a confirmation boundary, and idempotency/retry guidance, so the agent knows the operational conditions for calling it. It stops short of explicitly naming alternative evidence-recording siblings and when to prefer each.

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?

Adds rich non-obvious behavior: each call self-limits to ~8s because the gateway kills long-held requests, 'pending' returns retryAfterSeconds, and 'processing' means an ACH clearing over ~4 business days. Annotations already cover the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true). Minor tension: the description frames this as 'a read' while readOnlyHint is false, but this is a conservative annotation rather than a stated contradiction.

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

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

Front-loads the core action and per-status handling, and most sentences carry real information. The trailing Prerequisite/Canonicality/Idempotency/Confirmation-boundary block is largely generic boilerplate that dilutes rather than adds tool-specific value.

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

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

With no output schema, the description supplies the full status enum and what each value means, plus prerequisites and canonicality guidance. An agent has everything needed to poll correctly and 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 only 33%, so the description should compensate more than it does. It implies formationId (the incorporation payment) and the ~8s wait behind maxWaitSeconds, but never explains _corply_context or confirm the required parameter's meaning. Adequate but leaves the nested context object 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?

States a specific verb and resource: waits for the incorporation payment to land and reads from Corply's own payment records. It clearly distinguishes itself from siblings like get_payment_pipeline_status, list_payment_requests, and request_payment, which it explicitly routes to.

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 per-state instructions that leave nothing to inference: loop while 'pending', STOP on 'processing', re-run request_payment on 'failed'/'expired', share the checkout link on 'unpaid'. Explicit when-to-use, when-to-stop, and named alternative tools.

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

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

Beyond the annotations, the description discloses meaningful behavior: previously rejected names short-circuit to false without a provider call (caching), a null result specifically means only that provider request failed, and the outcome is advisory rather than blocking. It adds idempotency and confirmation guidance, though some of that text reads as generic template boilerplate rather than tool-specific detail.

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 first two sentences are well front-loaded and dense with real information, but the trailing Prerequisite/Canonicality/Idempotency/Confirmation-boundary block is boilerplate that restates generic policy ('plus every prerequisite stated above', 'obey the tool-specific retry key or guarantee') without adding tool-specific content.

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-style lookup with no output schema, the description covers return semantics (available true/false/null and what null means), advisory status, prerequisites, and retry behavior. What is missing is per-parameter documentation, but the overall picture is sufficient for correct invocation.

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

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

Schema description coverage is 0%, so the description has to carry the load and does so only partially: it tells the agent to pass selectedName exactly as saved and to preserve alternative order (which explains the 5-item cap on similarNames), but formationId and the _corply_context object are never explained.

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

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

The first sentence names a specific verb and resource (check company name availability) and scopes it precisely: the formation's saved name plus up to five alternatives via OpenSOSData. That is enough to tell it apart from domain-related siblings like check_company_domain, though it never names the neighboring tools 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 context is implied rather than stated: 'results are advisory and never block document generation' and 'Corply operations performs the mandatory state check immediately before filing' tell an agent that this is a non-blocking pre-filing lookup. A prerequisite (authenticated active company access) is given, but no explicit when-not-to-use or named alternative appears.

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 (readOnlyHint=false, destructiveHint=false, openWorldHint=true), and the description adds that this triggers a live DNS lookup plus retry/idempotency guidance. However the retry clause is circular ('obey the tool-specific retry key or guarantee; if none is stated...') and the confirmation-boundary sentence is a generic disjunction that calls the operation 'this read' despite readOnlyHint=false — the tension is hedged by 'reversible save', so it is loose rather than a hard contradiction, but it adds little tool-specific behavior.

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

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

The purpose is front-loaded in the first sentence, but the remaining three labeled clauses are template boilerplate: a prerequisite pointer to nonexistent 'above' text, a circular retry rule, and a long disjunctive confirmation list. Several sentences do not earn their place for a single-parameter DNS recheck.

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 low-complexity recheck the definition covers purpose, a (vague) prerequisite, retry posture, and confirmation boundary, and it points at actual_tool_output/context_engineering in place of an output schema. It omits anything about what happens on DNS failure, timeout, or partial verification, and its prerequisite reference is broken, so it is only minimally 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?

There is one parameter (_corply_context) with a nested id/receipt object and 0% schema description coverage, and the description says nothing about it. Even allowing that it is a plumbing/context object rather than a business parameter, the definition does not compensate for the coverage gap in any way.

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

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

The first sentence states a specific verb and resource: recheck the connected domain's DNS and return each record's verification state. That clearly distinguishes it from connect/disconnect/set_domain_auto_renew, though it never names its closest siblings (get_email_domain, inspect_email_domain), so an agent must infer which one to pick.

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

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

The only usage signal is 'Recheck ... now', implying use when state may be stale, and a dangling 'plus every prerequisite stated above' that references text not present in this definition. No when-not guidance and no routing against get_email_domain or inspect_email_domain, which are the obvious alternatives for the same resource.

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

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

Annotations only declare readOnlyHint=false, destructiveHint=false, openWorldHint=false. The description adds real behavioral context beyond that: the checkout may be reused, nothing is charged until payment occurs, and an already open/clearing/paid checkout is never charged again. Idempotency, canonicality and confirmation-boundary notes are somewhat generic boilerplate, which keeps this from a 5.

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 purpose and payment semantics are front-loaded and useful, but the trailing Canonicality, Idempotency and Confirmation boundary sentences read as templated boilerplate that could apply to many tools. Roughly half the text earns its place; the rest dilutes the signal.

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

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

No output schema exists, and the description does state what is returned ('a link a company manager opens to pay') and clarifies that payment has no side effect on the charter or filing. Combined with prerequisites, this is nearly complete for a checkout-link tool; only the parameters remain undocumented.

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% across 3 parameters (companyId, caseId, _corply_context), and the description never explains any of them. It compensates with no parameter-level detail at all, so the agent gets nothing beyond the schema's bare types. Well below the 3 baseline that would apply if the schema carried its own 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 ('Open (or reuse) the Corply-hosted Corply Pay checkout') scoped to the 'itemized, operator-assessed Delaware charter amendment quote', and the return value ('a link a company manager opens to pay'). This is clearly distinguishable from the sibling get_charter_filing_quote (which retrieves the quote) and await_payment.

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 a clear precondition ('Both approvals and a fixed quote are required') and draws a sharp boundary ('Payment does not itself change the charter or submit a filing'). It does not explicitly route the agent from get_charter_filing_quote or to await_payment, so it stops short of full alternative-naming guidance.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, openWorldHint=true, so the write/non-destructive profile is covered. The description does add real behavioral value beyond that: 'rechecks availability before saving' and 'registers only after payment clears' explain the payment gating, and the idempotency/retry guidance is useful. However much of the canonicality/idempotency/confirmation block is generic template text, and the confirmation line lists 'this read' among categories for a tool annotated as a write, which is loose but not a strict contradiction.

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 purpose is correctly front-loaded in the first sentence, but the following canonicality, idempotency and confirmation-boundary sentences are reusable template prose rather than tool-specific guidance, and the broken 'stated above' reference undercuts the structure.

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

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

For a 10-parameter, nested-object, no-output-schema write tool, the description covers prerequisites, availability recheck and payment gating, which is meaningful. It is still thin on the actual save/registration flow — how quoteId and registrantReviewToken are obtained and what happens between save and registration — leaving the agent to reconstruct the pipeline from sibling names.

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 80%, so the schema already documents the nested inboxes, registrant, termYears and token parameters well. The description only gestures at them in aggregate ('registration term, inbox plan and confirmed registrant contact') without adding format, default or dependency detail, so the baseline 3 is appropriate.

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

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

States a concrete verb+resource: 'Save a searched domain, registration term, inbox plan and confirmed registrant contact', and the title reinforces it. It is clearly distinguishable from read-only siblings like search_company_domains or check_email_domain, though it never explicitly names the upstream search step or the downstream start_company_domain_checkout it feeds into.

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 only usage signal is 'Prerequisite: authenticated active company access plus every prerequisite stated above' — the phrase 'stated above' is dangling boilerplate with nothing preceding it, so the prerequisite chain is unusable. No alternatives or when-not-to-use conditions are offered (e.g. when to call search_company_domains first).

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 genuine behavioral context beyond that: an idempotency/retry protocol, a canonicality note about trusting actual_tool_output, and a mandatory fresh-confirmation requirement — useful 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?

The purpose is front-loaded and the parenthetical is efficient, but the body is padded with generic boilerplate sections (Canonicality, Idempotency, Confirmation boundary) and a dangling reference to prerequisites 'stated above'. Some sentences do not earn their place for this specific tool.

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

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

No output schema exists, and the description only gesturally points to 'returned actual_tool_output and context_engineering' rather than describing what removal yields. It does cover auth prerequisite, retry behavior and confirmation, which is adequate for a destructive single-action tool but leaves the post-call state under-explained.

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%, but the only parameter is the infrastructure-level _corply_context object (id/receipt), not a domain-specific input. The description adds no explicit parameter meaning, though it alludes to a 'tool-specific retry key' that might relate to the receipt. Baseline 3 is fair given the parameter is a system context wrapper.

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 ('Remove a chosen domain from the company's checkout before it is paid') and clarifies scope with the parenthetical that the founder decided not to register it. This distinguishes it reasonably from siblings like choose_company_domain and start_company_domain_checkout, though it never names them.

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

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

Provides a conditional context ('before it is paid') and a prerequisite ('authenticated active company access'), plus a confirmation boundary. But it names no alternative tool and the prerequisite is self-referential ('every prerequisite stated above' — which does not exist here), leaving the when-to-use vs siblings 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 only declare readOnlyHint=false, destructiveHint=false, openWorldHint=true. The description adds rich behavioral context: omitted fields keep read values, confirmed facts fill blanks but never overwrite founder entries, a reading is confirmed once, Corply reopens to change, confirming does not accept the document, and more. This far exceeds the annotation baseline.

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, but the description is long and includes meta-sections (canonicality, idempotency, confirmation boundary) that are generic and somewhat repetitive. Several sentences restate the same constraints, reducing 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 the tool's complexity, minimal annotations, and no output schema, the description covers prerequisites, behavioral rules, idempotency, confirmation boundaries, and the relationship to document acceptance. It is complete enough for an agent to call 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?

With 0% schema description coverage and a complex 'values' object, the description provides a concrete example ('fileNumber', 'authorizedShares.0.count') and explains omitted-field behavior. It does not describe companyId, extractionId, or _corply_context, but those are standard or internal, so the compensation is substantial though not complete.

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

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

The description states a specific verb ('Record') and resource ('founder's confirmation of what Corply read from one document'), and clarifies the correction format. It does not explicitly differentiate from siblings like confirm_import_intake, so it falls 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?

It gives explicit when-to-call ('Only call after the founder explicitly confirms') and when-not ('Never confirm on their behalf without their explicit answer'), plus prerequisites and a confirmation boundary. No alternative tool is named, but the conditions are unambiguous.

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

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

Annotations already declare this a non-read-only, non-destructive, open-world write, and the description adds real behavioral detail beyond them: confirmation is refused while any check is unanswered, acknowledgedIssues must carry the accepted keys, confirming creates the import from confirmed values, and a Corply reviewer still reviews each document. It also addresses idempotency and a confirmation boundary. Some of that (canonicality, generic retry boilerplate) is stock filler, keeping it off a 5.

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 purpose and gating condition are correctly front-loaded, but the body sprawls into instructions for other tools (create_import_intake, uploadUrl, curl -F uploads, add_import_intake_url, read_import_intake loops). Those steps do not belong to this tool's own invocation and push the tool's actual parameter/behavior guidance into the middle of a wall of workflow text.

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

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

With no output schema, the description must cover return behavior, and it does signal the post-confirmation state (import created, reviewer step, missing items presented one question at a time). Prerequisites, idempotency, canonicality, and the confirmation boundary are all addressed. Only the unexplained parameters and the lack of any return-shape detail keep it from 5.

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 only partially does. It explains values ('only changed rows, keyed by review row key'), reviewHash, and acknowledgedIssues, but leaves intakeId, requestId, choices, accepted, team, and _corply_context unexplained despite being required or structurally significant. Partial compensation for a nine-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?

The opening sentence gives a specific verb and resource: 'Record the founder's confirmation of the reviewed details and import the company from them.' It implicitly distinguishes itself from the upstream siblings (create_import_intake, read_import_intake, add_import_intake_url) by naming them as prior flow steps. It never differentiates from close siblings like confirm_company_import_reading or import_company, 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?

States the gating condition explicitly: only after the founder chose 'Confirm and import' (or gave corrections), and 'Never confirm without that answer.' It also names the prerequisite flow (create_import_intake → read_import_intake until remaining is 0) and the acknowledgedIssues requirement. It does not contrast this tool with any alternative sibling, so usage is well-bounded but not alternative-aware.

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

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

Annotations mark it non-read-only, non-destructive, closed-world, but the description adds substantial context beyond them: safe retries preserve the same confirmation, prerequisite of authenticated active company access, the confirmation boundary requiring fresh explicit user confirmation, and that saved addresses need no Google lookup. This is rich disclosure of mutation/retry/authorization behavior.

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

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

The opening sentence carries the essential instruction, but the description is bloated with generic boilerplate ('Canonicality: invokes the shared backend action...', 'Idempotency: obey the tool-specific retry key...', 'Confirmation boundary: ...') that reads as templated policy rather than tool-specific guidance, diluting the front-loaded signal.

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

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

With no output schema, the description usefully names the returned confirmationText and the required legal-name attestation and Change-something affordance. Prerequisites, retry semantics, and boundaries are covered. Only gap is the undocumented nested _corply_context parameter.

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

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

Schema description coverage is 0%, so the description must carry the load, and it does: 'Send only formationId, reviewId, and confirmed:true; never reconstruct unchanged identity values,' which clarifies the intent of each required field and forbids populating stale identity data. It does not explain the nested _corply_context object, so not a full 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 action: recording acceptance of the exact server-held version of own details after a founder confirms, and contrasts it with save_application for edits and excludes document signing and invited-identity approval. It distinguishes itself from siblings, though the core purpose is embedded in a dense conditional opening sentence rather than stated crisply up front.

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

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

Explicit trigger (after founder chooses Confirm details or clearly confirms in text), explicit alternative path (Change something → save_application, then re-review), and explicit exclusions (does not sign documents, does not approve an invited founder's identity sharing). An agent knows when to call this versus alternatives.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the write-but-non-destructive profile is partly covered. The description genuinely adds context by clarifying that MX records and existing inboxes are untouched and that repeat calls are safe for sender updates. However, the canonicality/idempotency/confirmation boilerplate is generic template text that adds little tool-specific behavior, and the phrase 'no additional confirmation is needed for this read, reversible save...' is muddled for what annotations mark as a write.

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 purpose sentence is properly front-loaded, but more than half the text is reusable boilerplate about canonicality, idempotency and confirmation boundaries that is not specific to connecting an email domain. It inflates length without adding callable 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 no output schema, the description earns points for promising DNS records in the return. It also states the auth prerequisite in general terms. But the prerequisite is self-referential, retry behavior is deferred rather than specified, and there is no mention of what happens on a domain already connected or how it interacts with sibling domain 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 80%, so the schema already explains domain, replyToEmail, senderLocalPart and senderDisplayName well. The description adds no parameter-level meaning beyond that and does not mention the _corply_context object at all, so the baseline 3 is appropriate.

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

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

The opening sentence gives a specific verb and resource ('Connect a company-owned domain for Corply-sent mail') and even states the return artifact (DNS records to publish), which is valuable since there is no output schema. It does not explicitly name siblings like check_email_domain or inspect_email_domain, but the 'does not change MX records or existing inboxes' clause draws a useful boundary against adjacent domain tools.

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

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

'Safe to repeat for sender updates' gives one fragment of usage context, but the prerequisite sentence ('plus every prerequisite stated above') is a dangling, vacuous reference to text that does not exist. No alternative is named (inspect_email_domain, check_email_domain, disconnect_email_domain, update_email_sender) and no when-not guidance is provided.

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

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

Annotations only say it is a non-destructive, closed-world write; the description adds real behavior: each child keeps its own consent, filing, and payment gates, idempotency handling (obey the retry key, else inspect refreshed state), and a note to trust actual_tool_output rather than issue a state-recovery call. The canned 'confirmation boundary' sentence enumerates unrelated action classes and reads as boilerplate, keeping this below a 5.

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 sentence, but the body is a dense block of templated labels ('Canonicality:', 'Idempotency:', 'Confirmation boundary:'), and the confirmation sentence lists action categories that have nothing to do with this tool, so not every sentence earns its place.

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

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

For a 3-parameter mutation with no output schema and no parameter documentation, the description covers behavior but omits parameter meaning and return shape; it only obliquely implies output via 'trust the returned actual_tool_output and context_engineering'. Enough to call it, not enough to call it confidently.

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

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

Schema description coverage is 0% across 3 parameters (companyId, packageId, and a nested _corply_context object with id/receipt). The description only gestures at 'authenticated active company access' and never explains the required ids or what the context object is for, 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?

The description states a concrete verb+resource: retry creation of eligible child actions in a linked package after the primary role change completes. That is clearly distinct from siblings like get_linked_package and list_linked_packages, which read rather than continue. The jargon ('eligible child actions', 'primary role change') is a bit abstract but still scoping.

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 implies the trigger condition — after the primary role change completes, for eligible children — and gives an auth prerequisite. However, it names no alternatives and gives no when-not guidance, and the prerequisite 'every prerequisite stated above' references context the agent cannot see here, weakening the routing value.

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=false, destructive=false) but the description adds genuinely useful behavior: seven-day expiry, upload-only semantics, that anyone with the link can upload, and that download of company files is impossible. It does not describe the returned link payload or how the link is invalidated, so it stops short of full disclosure.

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

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

The operative sentence is front-loaded and clear, but the bulk of the text is reusable boilerplate about canonicality, idempotency, and confirmation boundaries that adds little tool-specific signal. Roughly half the description is generic policy text rather than meaning about this 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?

With no output schema, the description should explain what the caller receives (a link URL? an id?), but it only says to trust 'the returned actual_tool_output and context_engineering', which is not actionable. The link's behavioral constraints are well covered, but the return contract and the _corply_context parameter remain unexplained for a tool that produces an artifact.

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% across two parameters, so the description must carry the load and does not. companyId is only obliquely referenced via 'authenticated active company access', and the nested _corply_context object (id/receipt) is never mentioned at all, leaving the agent to guess its role.

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

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

The first sentence states a precise verb+resource+scope: creating a seven-day upload-only webpage link for company PDFs. It is clearly distinguishable from sibling upload_company_import_document (which presumably uploads a file directly) and add_import_intake_url, because the description specifies the artifact being produced and its constraints.

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 concrete usage context ('Present/open it while continuing step-by-step import questions') and a prerequisite ('authenticated active company access'). However, it never names an alternative tool or states when this link is preferable to add_import_intake_url or upload_company_import_document, so routing between siblings still requires 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?

With annotations declaring readOnlyHint=false, destructiveHint=false, openWorldHint=false, the description goes well beyond them: it enumerates what the tool does NOT do (no legal advice, no filing, no charging money, no share issuance or cap-table mutation), notes the share-sale fee exemption, and warns to read the returned gate object rather than assume approval. The 'confirmation boundary' sentence reads as generic boilerplate and its phrase 'this read' sits awkwardly next to a create operation, but it is a category list rather than a claim about this tool, so it is not a true annotation contradiction.

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 purpose and sibling routing are correctly front-loaded in the first two sentences, but the back half drifts into generic template boilerplate (Canonicality, Idempotency, Confirmation boundary) that restates standing policy rather than tool-specific behavior. It is denser and longer than it needs to be for the information actually delivered.

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

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

There is no output schema, and the description compensates by telling the agent to inspect the returned gate object and to trust actual_tool_output/context_engineering rather than adding a recovery call. Prerequisites and idempotency are covered. The remaining gap is the undocumented intake payload, which an agent would still have to guess at.

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 usefully pins down companyId ('exact'), idempotencyKey ('stable'), and the policyVersion value, and it hints at actionKind through the enumerated kinds. However it says nothing about the shape or expected contents of the nested 'intake' object or the 'title' field, which are non-trivial gaps for a 7-parameter tool with nested objects.

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

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

States a specific verb and resource ('Create a draft case for one canonical one-time corporate action') and immediately distinguishes itself from the nearest sibling by naming propose_charter_amendment and describing the legacy/share-sale intake scope. An agent can tell it apart from the other ~130 tools 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?

Explicit when-to-use and when-not: name/authorized-share amendments go to propose_charter_amendment, while this tool preserves historical cases and handles the separate share-sale intake. It also prescribes the exact policyVersion and states the prerequisite (authenticated active company access plus the policy approval gate), so nothing about routing is left 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 only cover the safety triad (readOnly=false, destructive=false, openWorld=false); the description adds genuinely non-obvious behavior: the package stages a replacement and/or cliff buyback, the departure is only proposed at this step, and child actions with separate approvals and payment gates materialize after completion. The idempotency/confirmation paragraphs are generic filler, but the staged-async-pipeline disclosure is real value.

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 flow are front-loaded, but the Canonicality/Idempotency/Confirmation-boundary paragraphs are generic policy boilerplate that could apply to nearly any tool, and the confirmation clause enumerates categories ('read, reversible save, explicit fact/evidence record...') that don't match this write tool. 'Every prerequisite stated above' is pure waste.

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

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

For a complex nested-parameter write tool with no output schema and zero schema descriptions, the description covers the high-level pipeline and idempotency expectations but omits anything about the required kinds/enums, the eligibilityConfirmed const, identifier fields, or what the returned package contains. Partial coverage only.

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% across 6 parameters, including nested objects with required enums (kind: remove_director/resign_officer, etc.) and fields like eligibilityConfirmed, allocationId, shareCount, and the three idempotencyKeys. The description only gestures at 'replacement' and 'cliff buyback', leaving the overwhelming majority of parameter meaning undocumented anywhere.

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 concrete verb+resource ('Prepare one visible departure package') and names the bundled components ('staged replacement and/or eligible cliff buyback'), which distinguishes it from the single-purpose siblings propose_governed_departure / propose_governed_replacement / propose_cliff_repurchase. However it never explicitly says it is the packaging/aggregate variant of those siblings, so differentiation is inferential 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?

The only when-to-use signal is the flow note that 'the departure is proposed now; child actions are created only after it completes', which is behavioral rather than selection guidance. No alternatives are named, and the prerequisite sentence ('plus every prerequisite stated above') is circular boilerplate pointing at text that does not exist.

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 readOnlyHint=false, but the description says 'no additional confirmation is needed for this read,' implying a read-only operation. That directly contradicts the annotation, which marks this as not read-only. The rest of the description is rich, but this inconsistency forces a 1 under the rubric.

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, but the description is bloated with downstream-tool instructions, generic boilerplate about canonicality, idempotency, and confirmation boundaries. Much of this does not help an agent select or invoke create_import_intake correctly.

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

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

Given the absence of an output schema, the description does explain returned artifacts like uploadUrl and curlExample. It also covers prerequisites and the broader import workflow. It falls short on the one parameter and contains misleading confirmation-boundary language, so it is 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 only parameter is the nested _corply_context object with id and receipt fields. The description never mentions or explains this parameter, so it adds no meaning beyond the schema 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 and resource: 'Open a document dump for importing an existing company' and 'Start an existing-company import from the founder's documents.' It clearly distinguishes this intake-creation step from siblings like add_import_intake_url, read_import_intake, and confirm_import_intake.

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

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

Explicitly says to use this instead of asking for company details, then gives the conditions for opening uploadUrl vs. shell uploads via curlExample, and routes public PDF links to add_import_intake_url. It also prescribes the subsequent read_import_intake and confirm_import_intake flow.

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

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

The description adds genuine behavior beyond the annotations: child actions are staged until the appointment completes and retain independent signing and settlement gates, plus canonicality and idempotency-retry guidance. However, the 'confirmation boundary' sentence is misapplied template text — it lists this tool among 'this read, reversible save, explicit fact/evidence record, link preparation', which conflicts with a create tool whose readOnlyHint is false and muddies the safety picture.

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 specific purpose is correctly front-loaded in the first two sentences, but the remainder is padded with repeated policy blocks (canonicality, idempotency, confirmation boundary) that read as shared boilerplate rather than tool-specific content. Several sentences are not earning their place for this particular 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?

For a no-output-schema, deeply nested, mutating composite tool, the description omits essentially all field-level meaning and gives no usable prerequisite or alternative-selection guidance. The staging/gating behavior helps, but coverage of the input contract and sibling routing is far short of what an agent needs to invoke 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 0% for a schema with three nested objects and many required fields (issuance.shareCount, pricePerShare, vestingStart, electionDecision, etc.), yet the description explains none of them. It only hints that issuance and ipAgreement are alternative/optional components, leaving the majority of parameter semantics 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?

The opening sentence gives a concrete verb and resource — prepare a package combining an appointment with restricted stock issuance and/or an IP agreement for the same person — and the 'and/or' phrasing distinguishes it from the single-purpose siblings propose_restricted_stock_issuance and propose_ip_assignment. The rest of the text is generic policy boilerplate that does not sharpen the purpose further.

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 pick this composite tool versus the individual propose_* siblings, which is exactly the decision an agent faces. The only stated prerequisite is 'authenticated active company access plus every prerequisite stated above', a circular reference to text that does not exist in this description.

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

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

With destructiveHint=true already supplied by annotations, the description still adds substantive consequence information: acceptance supersedes any published packet, opens a new draft, requires all signatures to be re-collected, and notifies all affected founders. That is exactly the kind of irreversible-effect detail an agent needs before 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?

Purpose and consequence are front-loaded, but the back half is generic governance boilerplate (Canonicality, Idempotency, Confirmation boundary) that does not add tool-specific value. 'plus every prerequisite stated above' is also a dangling reference to text not present in this description.

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?

Behavioral consequences for a destructive, open-world mutation are well covered, and no output schema exists so return values need no explanation. However, with 5 parameters at 0% schema coverage and a nested _corply_context object, the parameter story is materially incomplete.

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

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

Schema description coverage is 0% across 5 parameters, so the description carries the full burden, yet it only mentions 'with a reason'. formationId, requestId and the decision enum are left entirely to the schema, and _corply_context receives no explanation at all.

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 pair (accept/reject) and resource (a founder's formation-change proposal), plus the actor constraint 'only the incorporator may'. It does not name the sibling propose_formation_change, but the phrase 'founder proposal' makes the counterpart inferable, so it falls just 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?

Gives a clear qualifying condition for calling ('only the incorporator may accept/reject'), a prerequisite (authenticated active company access) and an explicit 'confirm before accepting'. It never states when NOT to use this tool or names the alternative path, 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?

Rich disclosure well beyond the annotations: the draft is hidden from everyone but uploads and history are retained for support restoration, cofounders get email and in-app notices, auth/active-access prerequisites are stated, and idempotency and canonicality behavior are addressed. This is consistent with destructiveHint=true and adds real operational context.

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

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

Purpose and scope are front-loaded, but the trailing canonicality/idempotency/confirmation-boundary boilerplate is templated and partly repeats the earlier confirmation instruction. It is longer than the concrete guidance requires.

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 mutation with no output schema, the description covers prerequisites, confirmation, downstream effects (retention, notices) and points to trusting actual_tool_output. Return-shape detail is absent but the tool explicitly delegates that to the returned payload.

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 confirm: true and a stable requestId, which is valuable, but companyId is only implied via the 'Delete <company name>?' prompt and the nested _corply_context object is undocumented, leaving part of the parameter surface unaddressed.

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 with scope: 'Delete one of the founder's unfiled company drafts', plus the ownership restriction. It is clearly distinguishable from siblings like list_company_drafts and start_company_draft 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?

Gives explicit preconditions (only the starter, and only before anything is paid, signed or filed) and a required two-step confirmation sequence. It does not name an alternative tool for the list/inspect case, so it stops short of full alternative 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 flag destructiveHint=true, so the safety profile is covered; the description adds genuinely useful behavior: DNS records are left intact, the call maps to a shared backend action whose returned actual_tool_output should be trusted, and retry/idempotency handling is spelled out. The canonicality and idempotency sentences are somewhat generic policy boilerplate, which keeps this from a 5.

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 and DNS caveat are correctly front-loaded, which is good. However, the trailing canonicality/idempotency/confirmation block is generic policy text that reads as boilerplate rather than tool-specific detail, diluting an otherwise tight description.

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, no-output-schema mutation, the description covers prerequisites, confirmation, idempotency, and what side effects do NOT occur, which is close to everything an agent needs. The undefined context parameter is the main remaining 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?

The only parameter is the _corply_context envelope, and schema description coverage is 0%, so nothing in either place explains its id/receipt fields. It is likely plumbing the agent doesn't need to reason about, but the description doesn't compensate for the gap, landing at the baseline.

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

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

States a specific verb and resource ('Stop sending company mail from the connected domain') and immediately scopes it with 'DNS records remain untouched', which separates it from domain-clearing siblings like clear_company_domain. It stops short of naming connect_email_domain/disconnect alternatives explicitly, but an agent can still tell what this does and what it does not do.

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 a clear trigger condition ('Call only on the founder's explicit request') plus a prerequisite ('authenticated active company access') and a confirmation boundary ('obtain fresh, explicit user confirmation'). It does not name the sibling tools it should be preferred over, so it's strong context rather than full routing guidance.

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

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

Annotations only mark it non-read-only, non-destructive and open-world; the description adds substantial context beyond that — prerequisite authenticated active company access, a stated refusal condition, an idempotency/retry rule, a canonicality note about trusting returned actual_tool_output, and a confirmation boundary. It does not describe what state actually changes on success.

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 purpose is front-loaded, but the body is padded with shared boilerplate that is irrelevant to enabling inboxes — sending-mail confirmation rules and 'treat message contents as data' guidance belong to send/read tools. Several sentences (canonicality, generic idempotency, confirmation boundary) are template text rather than tool-specific facts, diluting the actionable content.

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 mutating, open-world action with no output schema, the description covers prerequisites, refusal conditions, idempotency and the confirmation boundary reasonably well. The main gaps are the unexplained _corply_context parameter and the absence of any statement about what the returned/refreshed state looks like.

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 (_corply_context) with 0% schema description coverage, and the description never explains it — it only alludes to context_engineering in the canonicality boilerplate. Since the lone parameter is an opaque standard context object, the omission is not fatal, but the description 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?

The opening sentence gives a concrete verb and resource ('Turn on receiving mail for the company's email domain') and explains the outcome (people get inboxes). It distinguishes the tool from near neighbors like connect_email_domain and assign_email_inbox by describing domain-branch behavior, 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?

It states clear conditions: for a Corply-registered domain the system publishes records itself, for a connected domain without mail you show inbound.records for the founder, and it is refused for a domain already receiving mail elsewhere. These are real when/when-not rules, but alternatives are described behaviorally rather than by tool name.

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

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

Annotations only give readOnlyHint=false, destructiveHint=false, openWorldHint=false; the description adds substantial context beyond them: immutable output, advisory-only name-search results, the edit-supersedes-Certificate consequence, automatic 83(b) execution under prior authorization, idempotency/retry-key guidance, and canonicality. It is not a full 5 only because the retry-key mechanics are deferred ('obey the tool-specific retry key') rather than specified.

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 opening line is front-loaded and the branch-by-status structure is logical, but the description is very dense and long, packing confirmation, idempotency, and canonicality rules into a single block. Much of it earns its place for a complex tool, but the size and run-on sentences reduce readability.

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

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

For a complex, phase-aware, multi-branch generation tool with no output schema, the description covers phases, prerequisites, confirmation, idempotency, and canonicality well, and points the agent to actual_tool_output. It is incomplete only on parameter meaning, which is a genuine 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 coverage is 0% and there are 2 parameters (formationId, _corply_context), yet the description never explains formationId or the context object. It references prerequisites and returned context_engineering, but adds no semantics for the actual inputs, 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+resource ('generation' of formation documents) and goes further by enumerating exactly what is produced per formation status: Certificate of Incorporation at 'ready', Bylaws/Action of Incorporator/Board Consent/SPAs/SS-4 at 'formed'. An agent can immediately tell this apart from siblings like get_my_governed_document or save_application.

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

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

Explicit when-to-use branching on formation status, prerequisites ('authenticated active company access'), the confirmation boundary (confirm when checkpoint=true, but no approval for automatic 83(b) retry), and a warning that editing reopens the formation and requires re-generation. When-not and alternative conditions are spelled out rather than left 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?

Goes well beyond the readOnly/non-destructive annotations by disclosing privacy boundaries (never returns SSNs, identity documents, provider credentials, or KYC payloads), the membership roles required to receive a handoff URL (owner/founder/cofounder/operator), a sandbox-vs-production warning, idempotency, and canonical read semantics. These are substantive behavioral facts 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?

Purpose and privacy boundaries are front-loaded, which is good, but the labeled-section format (Canonicality/Idempotency/Confirmation boundary) is verbose. The confirmation-boundary sentence in particular enumerates unrelated action types (reversible save, evidence record, plan refresh) that add little for a pure 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?

Behaviorally rich for a read tool — covers privacy, auth roles, environment, and idempotency — and does describe the possible return states despite there being no output schema. The gaps are the undocumented parameters and the absence of explicit sibling routing, which leave the definition short of 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 0% and the description says nothing about companyId, applicationId, or the nested _corply_context object. The parameter names hint at meaning and the schema encodes UUID formats, but the description contributes no compensating semantics for the three parameters, so it fails the burden it carries 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 and resource ('get_bank_onboarding_status') and describes exactly what it returns: a Mercury prefill handoff, an in-flight/reconciliation state, or the direct Mercury fallback. Its 'First tool for opening a company bank account' framing implicitly positions it ahead of siblings like start_bank_onboarding and reconcile_bank_onboarding, but 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?

The prerequisite ('authenticated active company access') and the confirmation boundary give some usage context, and 'First tool' implies it precedes the other bank-onboarding siblings. However, it never states when to prefer this over start_bank_onboarding or reconcile_bank_onboarding, so 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 cover readOnly/destructive/closed-world, but the description adds real behavioral context: the auth prerequisite ('authenticated active company access'), idempotency ('safe to repeat'), canonicality ('reads current server state and does not manufacture company facts'), and the important clarification that rendering is not consent or issuance. The 'Confirmation boundary' sentence is largely boilerplate covering unrelated action types, which dilutes rather than contradicts the value.

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 purpose is front-loaded and the labeled sections (Prerequisite, Canonicality, Idempotency, Confirmation boundary) aid scanning. However, the confirmation-boundary sentence enumerates unrelated operations ('reversible save, explicit fact/evidence record, link preparation, plan refresh') that are irrelevant to a read tool, adding length without value.

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

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

With no output schema, the description carries the return-value burden and does so: issued shares, ownership percentages, projected status, authorized and unissued shares, plus rendered UI elements. Prerequisites and the pre/post-incorporation distinction are covered. The remaining gap is parameter-level detail, which is left entirely to the undocumented 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 0%, and the description says nothing about companyId or the nested _corply_context object (with its minLength constraints and dependentRequired receipt/id rule). With zero schema coverage the description is expected to compensate, and it does not — an agent gets no help on what either parameter means or when the context object 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 and resource ('Return the company's ownership ledger') and disambiguates two operational states: incorporated companies get issued shares and ownership percentages, pre-incorporation gets a projected cap table with authorized/unissued shares. It is clear enough to distinguish from generic reads, but it never names the close sibling get_company_stock_ledger or import_cap_table, so an agent must still infer the boundary.

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 concrete when-to-use guidance: call proactively in Codex with MCP Apps while reviewing saved founder equity or the final application, without waiting for the founder. That is a clear trigger condition. It stops short of naming alternatives or when-not-to-use cases (e.g., versus the stock ledger tool), so it is not 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=true and destructiveHint=false, but the description adds real context: idempotency ('safe to repeat'), canonicality (reads current server state, does not manufacture facts), the confirmation boundary, and the pass-through-at-cost nature of the state charge. The enumerated funding-status values, including legacy_review requiring Ops reconciliation, further clarify behavior.

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

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

The returned fields are front-loaded usefully, but the back half is boilerplate ('Prerequisite', 'Canonicality', 'Idempotency', 'Confirmation boundary') with one sentence that defers to non-existent 'prerequisites stated above.' The funding-status parenthetical is dense but earns its place.

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

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

With no output schema, the description correctly covers the return payload in detail, but it leaves the input side unexplained (two required UUIDs and a nested context object) for an agent that must supply all three. Prerequisite wording that points to absent text further reduces completeness.

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

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

Schema description coverage is 0% across 3 parameters, so the description carries the burden and does not meet it. companyId, caseId, and the nested _corply_context object are never mentioned; only an oblique 'approved governed charter amendment' hints at caseId.

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?

It names a specific verb+resource (read a charter filing quote) and enumerates the returned components: Delaware state charge, Corply filing fee, total, and Corply Pay funding status. It is clearly distinguishable from mutation siblings like checkout_charter_filing, though it never names that alternative 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: it applies to 'an approved governed charter amendment' with 'authenticated active company access.' The 'plus every prerequisite stated above' clause is a self-reference to text that isn't in this description, so it gives no actionable when-to-use guidance and does not contrast with checkout_charter_filing.

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/destructive=false, but the description adds genuine behavioral context beyond them: idempotency (safe to repeat), canonicality (reads live server state, invents no facts), and an explicit confirmation boundary for this read. The card-number prohibition is useful operational context; only the templated 'confirmation boundary' enumeration edges toward boilerplate.

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 returned fields are well front-loaded in the first sentence, but the definition then carries three label-prefixed boilerplate blocks ('Prerequisite', 'Canonicality', 'Idempotency', 'Confirmation boundary') whose length is disproportionate to a simple read and partly restates the annotations.

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 tool with no output schema, the description usefully enumerates what comes back (dates, services, pending changes, masked methods), which is the right way to compensate. The gap is the input side: with 0% schema coverage on a nested context object, the definition leaves parameter usage unexplained.

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 never explains companyId or the _corply_context object (id/receipt). The phrase 'the connected company's' weakly implies the company is contextual rather than passed explicitly, but for two undocumented parameters including a nested object, that is insufficient compensation.

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 (the connected company's unified billing account), then enumerates the concrete content: cadence, selected services, paid-through/next-renewal dates, pending changes, masked methods. An agent can distinguish this from manage_company_billing purely from the description.

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 prerequisite (authenticated active company access) and a security rule (never solicit card/bank numbers in chat), which is real guidance. However, it never states when to prefer this over the sibling manage_company_billing, and 'plus every prerequisite stated above' is an opaque backward reference that gives the agent nothing actionable.

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

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

Annotations supply readOnlyHint=false, destructiveHint=false, openWorldHint=false, and the description adds meaningful context beyond them: it explains that resolving 'may materialize the same deterministic canonical plan but creates no external side effect', that no confirmation is required, and it states the auth prerequisite (authenticated active company member) plus idempotency/retry and canonicality rules. That reconciles the otherwise-surprising readOnlyHint=false for a 'get_' tool. It does not cover rate limits or the shape of the response, keeping it below 5.

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 buried in the second sentence behind a usage clause, and the text then repeats itself ('Prerequisite: an authenticated active company member' followed later by 'Prerequisite: authenticated active company access plus every prerequisite stated above'). Phrases like 'every prerequisite stated above' and the generic idempotency/confirmation-boundary boilerplate add length without adding tool-specific information.

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

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

There is no output schema, and the description compensates well by enumerating what is returned (caller/company context, lifecycle origin, formation/payment/filing/document/signature state, deterministic operating plan, execution boundaries). What is missing for a zero-required-parameter read tool is any documentation of the three real input parameters and how to scope/paginate via itemLimit and questionLimit.

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 4 parameters, so the description must carry the load and it does not: companyId, itemLimit, and questionLimit are never mentioned, nor is _corply_context. The only implicit hint is 'This connection acts in one company; switch companies before working on another company from whoami', which gestures at company scoping without telling the agent what the parameters do or their semantics.

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

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

The description states a clear verb+resource in the second sentence ('Returns the privacy-filtered caller/company context, lifecycle origin, formation/payment/filing/document/signature state...'), which is specific. It also seeds usage ('broad company briefing, company disambiguation, or a founder asking what matters next') but never contrasts itself by sibling tool name, so the agent must infer the boundary against tools like get_org, get_cap_table, get_status from the list 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 gives explicit use cases (broad briefing, disambiguation, 'what matters next') and an explicit exclusion: 'It is not a prerequisite for a goal-specific tool because every Corply result now carries server-authored context continuation.' That is genuine when/when-not guidance. It stops short of naming the alternative tools it is routing away from, and the surrounding canonicality/idempotency boilerplate dilutes it.

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

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

Beyond the readOnlyHint and destructiveHint annotations, the description discloses numerous behavioral traits: documents stay pending until admin acceptance, EIN format and name availability are only screening, the founder must never pay or sign, checkoutUrl is for personal payment authorization, and the operation is idempotent. It also states prerequisites and the confirmation boundary, providing rich operational context.

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

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

The purpose is front-loaded, but the description is heavily bloated with procedural instructions, cross-tool references, and policy statements. It mixes multiple concerns and is much longer than needed for an agent to select and invoke this tool correctly.

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

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

The description is thorough about workflow, prerequisites, idempotency, and confirmation boundaries, which is useful for a complex import-resumption tool. However, it omits any parameter semantics and does not describe the return shape despite there being no output schema, leaving a gap for safe 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 0%, and the description never explains the required companyId or the nested _corply_context object. It does not compensate for the absent parameter documentation at all, leaving an agent to infer both input meanings solely from the schema names.

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 clear verb+resource: 'Resume an existing company import,' and specifies the scope as shared checklist, documents, review decisions, and next actions. It does not explicitly distinguish itself from siblings like get_company_import_readings or read_company_import_documents, but the core 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?

It gives strong procedural context: resume an existing import, ask one multiple-choice question at a time, never assume documents or completion, and continue through the shared checklist. It states prerequisites and confirmation boundaries. However, it does not name alternative sibling tools or clearly state when not to use this one.

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

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

Annotations already cover the read-only, non-destructive profile, and the description adds genuine behavioral context beyond them: Corply reads PDFs and proposes facts with exact quote and page, values can be marked unverified or no_text_layer, confirming does not accept the document (a reviewer still does), and it is idempotent and reads current server state. These are useful disclosures not derivable 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 functional content is front-loaded and readable, but the tail is bloated with templated policy boilerplate ('Confirmation boundary: no additional confirmation is needed for this read, reversible save, explicit fact/evidence record, link preparation, plan refresh...'). The reference to prerequisites 'stated above' is dead weight.

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

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

With no output schema, the description does a reasonable job of describing what the caller will see (proposed values, exact quotes, page numbers, unverified/no_text_layer flags, per-document issues) and the auth prerequisite. The only real gap is that the input parameters remain unexplained.

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% across two parameters, and the description never mentions companyId or the nested _corply_context object at all. With low coverage the description is expected to compensate for undocumented parameters, and it does not.

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

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

The opening sentence gives a specific verb and resource: show what Corply read from each uploaded import document, which values are confirmed, and cross-document checks. This distinguishes it from the raw-document sibling read_company_import_documents and from confirm_company_import_reading, though the differentiation is implicit rather than 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?

It implies the workflow (present proposed values, have the founder confirm or correct, never confirm on their behalf) which points toward the confirm sibling, but it never names an alternative tool or an explicit when-not-to-use condition. The prerequisite line, 'plus every prerequisite stated above,' refers to text that does not exist, which weakens the guidance.

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

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

Annotations already declare readOnlyHint, destructiveHint=false and openWorldHint=false, but the description still adds real behavioral context: the ledger is append-only, reads current server state without manufacturing facts, is idempotent, and falls outside the confirmation boundary. That said, the confirmation-boundary sentence lumps in unrelated operations (reversible save, plan refresh) that do not apply to a read tool, diluting the signal.

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 functional sentences at the front are tight and well-ordered (what it reads, what is included, treasury-share caveat). The trailing confirmation-boundary clause sprawls into a list of unrelated operations, most of which have nothing to do with a read, padding the definition without adding value.

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

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

With no output schema, the description usefully sketches what the ledger returns (opening balances, issuances, repurchases, treasury vs. shareholder votes). But the prerequisite and confirmation sections are boilerplate referrals rather than real conditions, and parameter behavior is entirely unaddressed, leaving the definition only partially complete for a tool in a large sibling set.

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% across two parameters, and the description never mentions companyId or the nested _corply_context object, so it does not compensate for the gap. The agent gets no explanation of UUID formatting expectations or the role of the context receipt from the prose.

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 and resource ('Read the append-only stock ledger') and enumerates the contents (opening balance snapshots, completed issuances, repurchases), which is more than a restatement of the title. It does not, however, distinguish itself from a close sibling like get_cap_table, leaving the agent to infer why both exist.

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 resource name, but there is no explicit when-to-use guidance and no named alternative such as get_cap_table. The stated prerequisite ('authenticated active company access plus every prerequisite stated above') is circular and references text that does not exist in this definition, so it provides no actionable gating condition.

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, non-destructive, closed-world), so the bar is lower, yet the description adds real value: identity documents and forwarding-address details are intentionally excluded from output, it reads current server state without manufacturing facts, and it is idempotent. The long 'confirmation boundary' sentence is generic boilerplate enumerating action types irrelevant to a read tool, which slightly dilutes the otherwise strong disclosure.

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

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

The payload and usage guidance are front-loaded and useful, but the definition is bloated by a generic confirmation-boundary clause listing unrelated action types ('reversible save', 'plan refresh', etc.). Roughly a third of the text does not earn its place for a 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?

With no output schema, the description correctly enumerates the returned fields and their exclusions, which is helpful. But it leaves both input parameters undocumented, so an agent cannot tell what _corply_context is for or whether companyId is required.

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

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

Schema description coverage is 0% for two parameters, so the description must compensate and largely does not. It implies a single company via 'for one company', loosely mapping to companyId, but the nested _corply_context object (id/receipt) is completely unexplained 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 names a precise read with a specific verb and enumerates the exact payload: entitlement, activation/identity state, assigned U.S. mailing address, open-item count, secure web URL, and nextStep for one company. This cleanly separates it from siblings like get_mail_item, list_mail, and start_corply_mail_activation, which handle individual items, listing, and activation respectively.

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 when-to-use context ('mailbox readiness or address questions') and an explicit warning not to infer provisioning from a Corply Pay payment. However, it never names the alternative tools to call for activation (start_corply_mail_activation) or listing (list_mail), so routing is implied rather than spelled out.

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

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

Annotations already cover readOnlyHint/non-destructive, but the description adds real behavioral context: idempotency ('safe to repeat'), canonicality (reads current server state, does not manufacture facts), and the guarantee that a consent gate is never reported as satisfied. The only weak spot is the boilerplate confirmation-boundary line that mixes in unrelated operations.

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 purpose and gate explanation are useful and front-loaded, but the closing 'Confirmation boundary' sentence is bloated boilerplate referencing reversible saves, evidence records, link preparation, and plan refresh that have no bearing on this read tool. That is diluting text rather than earning its place.

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

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

For a read tool with no output schema, the description does sketch the return shape (gate, blockers, workflow, next step), which is helpful. However, with 0% parameter coverage and no output schema it leaves an agent guessing what identifiers to supply, so completeness is only marginal.

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 never explains caseId, companyId, or _corply_context. 'Company-scoped' hints at companyId, but nothing compensates for the fully undocumented parameters, so an agent gets no help on what to pass.

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 ('Get one company-scoped corporate-action case') and enumerates the returned content: approval/signature workflow, blockers, gate, and natural-language next step. This distinguishes it from siblings like list_corporate_action_cases (plural) and get_governed_action 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?

Provides meaningful constraints ('never infer a cap-table change from case status') and lists the gate kinds, but never states explicitly when to prefer this over list_corporate_action_cases, get_governed_action, or get_corporate_action_consents. The prerequisite line is circular ('plus every prerequisite stated above'), 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?

With readOnlyHint/destructiveHint already covering the safety profile, the description still adds real behavior: no signing secrets are returned, signed approvals do not imply shares issued or a filing accepted, the read is idempotent, and it reflects current server state. The prerequisite clause ('plus every prerequisite stated above') is circular and unhelpful, which keeps it from a 5.

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 purpose and return caveats are front-loaded, which is good, but the closing 'Confirmation boundary' sentence is boilerplate that enumerates unrelated operation types (link preparation, plan refresh, standing policy) and dilutes the message.

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

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

There is no output schema, and the description does sketch what comes back (signature progress, history on demand) plus important trust caveats about what signatures do not prove. Gaps remain around the _corply_context parameter and pagination/result shape, but overall an 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 parameter meaning. It does explain includeHistory (replaced requests and previous decisions) and implies companyId/caseId via 'this company case', but the nested _corply_context object is left completely unexplained, so it only partially compensates.

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

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

The opening sentence gives a specific verb and resource: 'Read signature progress for this company case.' An agent can distinguish it from mutation siblings like request_corporate_action_consents or remind_corporate_action_consents, but the description never names a sibling or scopes itself against get_corporate_action_case or get_signature_request.

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 only usage guidance is about a parameter ('Defaults to current requests; includeHistory shows replaced requests'). There is no statement of when to prefer this over list_corporate_action_cases, get_corporate_action_case, or get_signature_request, and no exclusions.

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

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

Annotations already declare readOnlyHint/destructiveHint=false, but the description adds non-obvious traits: canonicality ('reads current server state and does not manufacture company facts') and idempotency ('safe to repeat'), neither of which is in the annotations. The confirmation-boundary sentence is boilerplate policy text mixing in unrelated actions (reversible save, link preparation, plan refresh), which dilutes an otherwise useful disclosure.

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

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

The opening clause is well front-loaded, but the listing of four labeled clauses (Prerequisite/Canonicality/Idempotency/Confirmation boundary) pads a simple read tool, and the confirmation-boundary sentence enumerates unrelated operations that do not apply here.

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 tool with no output schema the description does identify the returned content (facts, source hash, certificate link), but it omits return shape detail and leaves the dangling 'prerequisites stated above' reference and undocumented parameters unresolved.

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 two parameters, so the description carries the burden of explaining companyId and the nested _corply_context object. It says nothing about either, so an agent gets no help on what to pass or why the context object exists.

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: 'Read the latest accepted ... charter facts, source hash and certificate link' tells the agent exactly what is returned. It positions itself against propose_charter_amendment ('before proposing a name or authorized-share amendment'), though it never names the sibling 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?

Gives a clear usage trigger ('before proposing a name or authorized-share amendment') and a prerequisite (authenticated active company access). However, the phrase 'plus every prerequisite stated above' refers to text that is not in this definition, leaving an unresolvable condition.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description adds a useful behavioral detail (returns null when no domain is set, idempotent, reads current server state) but the canonicality/idempotency/confirmation sentences read as generic boilerplate rather than tool-specific disclosure.

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

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

Purpose is front-loaded and the null-return note is valuable, but the Canonicality/Idempotency/Confirmation-boundary block is generic policy text that consumes most of the description without adding tool-specific meaning.

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

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

With no output schema, the description does sketch the return contents (state, sender, DNS findings, records), which helps. But it omits the sibling differentiation an agent needs to pick this tool and leaves the sole input parameter unexplained.

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 one parameter (_corply_context with nested id/receipt) has 0% schema description coverage and is never mentioned in the description, so nothing compensates for the gap. The nested context object's purpose and the required id/receipt relationship are left entirely 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?

States a specific verb+resource: reading the company's email-domain state, sender, DNS findings and records. This is clear and concrete, but it makes no attempt to distinguish itself from the near-identical siblings check_email_domain and inspect_email_domain, which an agent will have to disambiguate on its own.

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 a prerequisite (authenticated active company access) and a confirmation-boundary statement saying no extra confirmation is needed for this read. However, it never says when to choose this over check_email_domain or inspect_email_domain, so the usage context 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/mutating=false, so safety is covered, yet the description adds real context: immutability of the history, canonicality ('reads current server state and does not manufacture company facts'), and idempotency ('safe to repeat'). The confirmation-boundary sentence is largely boilerplate enumerating unrelated operations, but the idempotency and immutability claims are genuine value beyond annotations.

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

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

The useful content is correctly front-loaded in the first sentence, but the remainder is padded with labeled boilerplate ('Canonicality:', 'Idempotency:', 'Confirmation boundary:') and a dangling 'every prerequisite stated above' clause. Several sentences do not earn their place, though none are actively misleading.

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 tool with no output schema, the description usefully sketches what is returned and states an access prerequisite. However, it omits any explanation of the required formationId, and the boilerplate cross-reference leaves the prerequisite chain undefined, so an agent still lacks pieces needed to call it confidently.

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

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

Schema description coverage is 0% across 2 parameters, so the description must compensate and does not: formationId (a UUID with a specific pattern) and the nested _corply_context object are never mentioned. 'This company's' only loosely implies company scoping, leaving the agent to infer the identifier's role and format entirely from 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 ('Read') and enumerates the exact resources returned: immutable version history, open founder change proposals, recorded decisions, and editing authority. This cleanly distinguishes it from sibling mutation tools like propose_formation_change and decide_formation_change without needing to name them.

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

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

The only usage statement is 'Prerequisite: authenticated active company access plus every prerequisite stated above' — a vacuous cross-reference to text that does not exist in this description. There is no guidance on when to choose this tool over siblings such as get_current_charter or get_company_briefing, and no exclusions.

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

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

Annotations already establish the safe-read profile (readOnlyHint=true, destructiveHint=false, openWorldHint=false), so the bar is lower. The description still adds real behavioral context beyond the annotations: idempotency ('safe to repeat'), canonicality ('reads current server state and does not manufacture company facts'), a confirmation boundary, and the settlement caveat that equity payment is not complete until a trusted payment provider verifies it. That is genuinely additive, though the 'every prerequisite stated above' clause is noise.

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 read purpose is front-loaded in the first sentence, which is good. But the remaining text is padded with templated labels ('Canonicality:', 'Idempotency:', 'Confirmation boundary:') and includes a meaningless self-referential prerequisite clause, plus an unrelated sentence about equity settlement. It is not bloated to the point of uselessness, but several sentences do not earn their place.

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

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

With no output schema, the description does partially cover return content (gates, voter decisions, effect status, next step), which helps. But it omits any parameter semantics, the nested _corply_context object is undocumented, and the prerequisite statement is circular. For a read tool with a nested input object and zero schema description coverage, more completeness was needed.

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 there are 3 parameters (companyId, caseId, and a nested _corply_context object) with no descriptions. The description provides no explanation of what caseId or companyId denote or how they identify the action, and never mentions the nested context object. With low coverage the description is expected to compensate, and it does not, leaving parameter meaning essentially 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 names what is returned (action gates, frozen voter decisions, effect status, next step) and the title says 'View a company action', so the read intent is discernible. However, it never states the core identity of the resource being fetched (a single governed action keyed by caseId/companyId), and it gives no differentiation from close siblings like get_corporate_action_case, get_my_governed_document, or list_governed_actions. The result is a vaguely-scoped purpose rather than a precise verb+resource.

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 stated when-to-use versus alternatives among the many sibling read tools. The only guidance is a circular prerequisite ('authenticated active company access plus every prerequisite stated above') that references context that does not exist above it, so it conveys nothing actionable. No exclusions or conditions for selecting this over list_governed_actions or get_corporate_action_case 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 readOnlyHint=true, destructiveHint=false, and openWorldHint=false. The description adds useful behavioral context: it reads current server state, is idempotent ('safe to repeat'), and needs no additional confirmation. It also sketches the return shape (reviewMarkdown, checks, reviewHash). No contradiction with annotations.

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

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

The description is a single massive block that mixes this tool's behavior with a multi-step workflow for other tools. It is not front-loaded, the tool's own purpose is buried, and much of the text does not belong to this read tool, making it hard to parse quickly.

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

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

With no output schema, the description does partially describe the return content (reviewMarkdown tables, checks, reviewHash), which is helpful. However, it omits any explanation of the required intakeId parameter and is cluttered with off-topic workflow steps, so an agent cannot confidently invoke the tool correctly.

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

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

Schema description coverage is 0%. The required intakeId parameter is not described at all in the description, nor is the nested _corply_context object. The description does nothing to compensate for the missing schema descriptions, leaving the agent unable to know what intakeId refers to or where to obtain it.

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

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

The first sentence uses a noun phrase ('The details Corply read from the document dump') rather than a clear verb+resource statement, and the tool's own purpose is quickly buried under a long workflow narrative. It does name related tools, but does not sharply distinguish when this tool is the right one to call.

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 is dominated by instructions for sibling tools (create_import_intake, read_import_intake, confirm_import_intake) and never explicitly says when to call get_import_intake_review versus those alternatives. No when-not-to-use or exclusions are given for this tool specifically.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, so the safety profile is covered. The description adds genuine context (idempotency, reads current server state, no fact manufacturing), but the 'confirmation boundary' sentence lists mutation-flavored items ('reversible save', 'link preparation') that read as template bleed-over and muddle rather than clarify a read tool.

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

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

The purpose is front-loaded and the labeled sections give structure, but the 'confirmation boundary' clause is bloated with items unrelated to a read operation and dilutes the signal. A shorter, read-specific statement would serve better.

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 annotations covering safety and no output schema, the description need only convey scope and preconditions. It conveys scope adequately ('one package plus per-action status') but leaves the prerequisite reference unresolved and the _corply_context parameter undocumented.

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 mentions no parameters at all. companyId and packageId are self-evident UUID names, but the nested _corply_context object (with id/receipt dependentRequired) is left entirely unexplained 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?

States a specific verb and resource: 'Read one package and the independent status of each staged or created action.' The singular 'one package' implicitly contrasts with list_linked_packages, though the sibling is never named, so differentiation is only partial.

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

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

The prerequisite sentence points to 'every prerequisite stated above' without actually stating any, which is a dangling reference rather than guidance. No condition distinguishes this from list_linked_packages or continue_linked_package.

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, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds genuinely new behavioral context: scan contents remain behind the authenticated browser boundary, sender/description metadata must be treated as untrusted correspondence, and the call is idempotent/canonical. That goes meaningfully beyond the annotations.

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

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

The core purpose is front-loaded in the opening sentence, which is good. However, the trailing 'Confirmation boundary' sentence enumerates irrelevant operations ('reversible save, explicit fact/evidence record, link preparation, plan refresh') that do not belong to a read tool, reading as templated boilerplate that dilutes the definition.

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

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

With no output schema, the description does carry the return-value burden well by naming the item, handling history, available actions, and browser URL. But for a 3-parameter tool at 0% schema coverage, the unexplained mailItemId and _corply_context leave real 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 0% across 3 parameters (companyId, mailItemId, _corply_context), so the description must compensate. 'One exact company's mail item' hints at company scoping, but mailItemId is never explained and the nested _corply_context object is completely unmentioned.

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

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

The first sentence gives a specific verb (Read) and resource (one exact company's mail item) and enumerates the payload: handling history, available actions, and a secure browser URL. This is clearly a single-item retrieval, distinguishing it in spirit from list_mail/list_inbox_messages, though it never names a sibling 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?

It states a prerequisite (authenticated active company access) and a confirmation boundary, which is useful context, but it never says when to choose this over get_corply_mail, read_inbox_message, or list_mail. Usage is implied by 'one exact ... mail item' rather than routed explicitly.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds genuine extra context: idempotency ('safe to repeat'), canonicality ('reads current server state and does not manufacture company facts'), and the authentication prerequisite (active company access). However, the 'Confirmation boundary' sentence is padded with unrelated boilerplate (reversible save, plan refresh, standing policy) that dilutes rather than sharpens the read-specific behavior.

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

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

The purpose is front-loaded and the labeled clauses (Prerequisite, Canonicality, Idempotency) aid scanning, but the final sentence is bloated with an enumerated list of irrelevant confirmations. The dangling 'plus every prerequisite stated above' references nothing in a standalone definition and wastes space.

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

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

With no output schema, the description correctly names the return payload (hash and web signing URL), which an agent needs. It is nonetheless incomplete for a 4-parameter tool with 0% schema coverage, since the meaning of companyId, consentId, and pagination bounds is never established. Adequate but with clear 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 0%, so the description carries the full burden for four parameters, and it largely fails: it implies single-page reads but never explains the page range (1-100), and it says nothing about companyId, consentId, or the nested _corply_context object. Only the paginated-read concept is conveyed, leaving three parameters 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 and resource: reading one page of the exact frozen PDF addressed to the connected account, and names the payload (hash and web signing URL). It explicitly distinguishes itself from the signing counterpart with 'this does not sign or record review', so an agent can separate it from sign_my_governed_document 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 usage context ('Read all pages before deciding') and a negative boundary ('this does not sign or record review'), which routes the agent away from the signing tool. It never names the alternative tool explicitly or states a full when-not-to-use condition, so it stops short of the top tier.

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 readOnly/openWorld/destructive, and the description adds genuinely useful traits: idempotency ('safe to repeat'), canonicality ('reads current server state'), and confirmation boundary. However, the confirmation-boundary sentence is bloated boilerplate enumerating unrelated items (reversible save, fact/evidence record, link preparation) that don't apply to a simple read, diluting the useful signal.

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 first two sentences are tight and front-loaded, but the closing 'Confirmation boundary' sentence is an over-long list of mostly irrelevant items, and 'plus every prerequisite stated above' is a dangling reference with no antecedent in this definition.

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 no-output-schema read tool with annotations covering safety, the routing and idempotency context are helpful. But the sole parameter is undocumented and the dangling 'stated above' prerequisite leaves ambiguity an agent cannot resolve.

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 parameter (_corply_context with nested id/receipt) is never explained in the description. The orgId alias note is conceptually related but does not document the actual parameter the agent must supply, 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?

States a specific verb and resource ('Compatibility read returning the connected company') and explicitly notes that legacy orgId aliases the company ID. It also names the siblings it is not (whoami, get_company_briefing), so an agent can distinguish it 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?

Explicitly routes the agent: 'Use whoami to list your companies and get_company_briefing for company-specific work.' The 'Compatibility read' framing plus the alias note tell the agent when this legacy accessor is appropriate versus its alternatives.

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

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

Annotations already cover the read-only/non-destructive profile, and the description adds substantial context beyond them: idempotency ('safe to repeat'), canonicality (reads current server state, manufactures no facts), the auth requirement (recipient email + correct company, active company access), and an explicit prompt-injection guard on quoted PDF text.

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

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

Front-loaded with the core action and the alternative routing, but the tail is bloated with boilerplate policy jargon ('Canonicality', 'Idempotency', 'Confirmation boundary') that reads as templated filler and dilutes the actionable guidance.

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

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

With no output schema, the description carries the return-value burden and does so reasonably well by naming the formation, bundle, review URLs, webSignUrl and nextStep. Prerequisites and safety boundaries are covered; a bit more on pagination/nextPage mechanics would close the remaining 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 coverage is 0%, so the description must compensate, and it largely does: it explains the reviewUrl as the founder-shared link, documentId as a returned value to re-call with, and page with its default of 1. Only the _corply_context id/receipt pair is left 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: opens/resolves a Corply /sign/ link and returns the signer's bundle, review URLs, webSignUrl and nextStep. It is distinguishable from siblings like sign_bundle or get_linked_package, though the dual mode (link resolution vs. document text retrieval) makes the core purpose slightly diffuse.

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

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

Explicitly says 'Use this before generic intake when the founder brings a signature link,' which names a condition and a competing path. It also gives the follow-up invocation rule (call again with a returned documentId and page) and lists prohibitions (never start a company, regenerate documents, infer consent).

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 the safety profile (readOnly, non-destructive), and the description goes well beyond them by stating the auth prerequisite, canonicality (reads current server state, does not manufacture facts), idempotency (safe to repeat), and an explicit confirmation boundary. This is unusually rich disclosure of behavior an agent cannot get from structured fields.

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

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

The purpose is front-loaded, but the description then sprawls into a dense stream of billing, amendment, and policy rules that mix concerns and are hard to parse. Several sentences are tangential to invoking this read and would be better placed in their own tools' definitions.

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

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

For a complex, multi-parameter tool with no output schema, the description enumerates the returned fields and the key behavioral boundaries, which is substantial coverage. Gaps remain around the two ID parameters and the exact shape of the returned status object, but overall it is complete enough to call 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 40%, so the description should compensate. It does explain billingCadence and removedOptionalServices usage (preview semantics, consent requirement, omission behavior), but companyId and formationId receive no meaning beyond their names, and the relationship between the two is never clarified.

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

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

Opens with a specific verb+resource ('Return the formation status for a company ... or its latest formation') and then enumerates the fields returned, so the agent knows exactly what this read yields. It is distinguished from generic reads by its formation-specific scope, though it does not explicitly name a sibling it differs from.

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?

Guidance is present but is almost entirely conditional rules about parameters (when to pass billingCadence, when to pass removedOptionalServices, carrying the list into request_payment) rather than when to choose this tool over alternatives like get_formation_revisions or get_company_briefing. Usage is implied through the workflow narrative rather than stated as tool selection.

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 the description corroborates and enriches that by disclosing that confirming REPLACES the entire existing cap table, that confirm:false gives a parsed-holder preview, plus auth prerequisites and retry/idempotency guidance. This goes well beyond what the annotations alone 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?

Front-loads purpose and the destructive warning well, but the Canonicality/Idempotency/Confirmation-boundary block reads as generic template boilerplate that partially restates what the schema's idempotencyKey description already says.

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, no-output-schema mutation with a low-coverage schema, the description covers the safety-critical behaviors (preview, replace-all, confirmation, retry). Minor gaps remain only around a few low-risk parameters.

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

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

Schema coverage is low (17%), so the description has to compensate. It explains the critical confirm flag semantics (preview vs destructive replace) and the retry-key contract for idempotencyKey, and implies source via 'Carta/Pulley CSV export'. However csv, companyId, and the _corply_context object are not described.

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

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

States a specific verb+resource ('Import a cap table from a Carta/Pulley CSV export') and clarifies one-way semantics that Corply becomes the system of record, which clearly distinguishes it from the read-only get_cap_table sibling.

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

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

Explicitly gates on 'Owner/founder only' and prescribes a preview-first flow (confirm:false before confirming). It states the confirmation boundary but does not name alternative import paths (e.g. import_company, create_import_intake) an agent might confuse it with.

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

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

Annotations only cover readOnly=false/destructive=false/openWorld=true; the description adds substantial behavioral facts beyond them: documents stay pending until admin acceptance, EIN/name checks are screening not verification, never pay or sign for the founder (use checkoutUrl), idempotency/retry guidance, and canonicality handling. It also warns against assuming documents or completion exist.

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

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

The core import workflow is front-loaded and valuable, but the text is very long and pads onto generic boilerplate ('Canonicality', 'Idempotency', 'Confirmation boundary') that reads like appended policy rather than tool-specific guidance. The 'Confirm before creating' instruction sits awkwardly against the boilerplate 'no additional confirmation is needed' 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?

For an 11-parameter, nested-object mutation with no output schema, the description covers the workflow, post-import follow-ups (logo, email domain), and safety constraints well. Remaining gaps are the undocumented choices enum semantics and quantity, plus the internally muddled confirmation language.

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 compensates well: it defines the meaning of companyId (omit vs. resume), legalName ('exact legal name'), jurisdiction/entityType, formationDate, EIN, state file number, founderCount, and the stable requestId, and describes the one-question-at-a-time choices flow. It does not explain the choices enum values (have/corply/not_applicable) or quantity, so it falls short of complete 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?

Opens with a specific verb+resource+scope ('Import an existing Delaware C-Corp') and explicitly disambiguates from the sibling path: 'When the founder has formation documents, use create_import_intake instead.' It also clarifies what it is not ('This creates a company import, not a new state formation'), which lets an agent separate it from adopt_existing_company and start_company_draft.

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 explicit selection and exclusion rules: use create_import_intake if documents exist, otherwise this; omit companyId to create a separate company vs. provide it to resume an import. Prerequisites (authenticated active company access) and confirmation boundary are also stated, leaving little 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 supply the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true), and the description usefully adds that the save is reversible, that no confirmation is required, and how to handle retries/idempotency and the returned actual_tool_output. It adds real substance beyond structured fields, though 'every prerequisite stated above' is unverifiable filler.

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, but the body is padded with boilerplate labeled sections (Canonicality, Confirmation boundary) and a vacuous 'every prerequisite stated above' clause. The idempotency guidance earns its place; the rest is generic policy text that dilutes the useful signal.

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

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

With no output schema, the description covers what an agent needs operationally for an open-world, state-touching read – prerequisites, retry behavior, and the fact that the save is reversible and confirmation-free. The only gap is routing versus sibling inspection tools and the undocumented _corply_context object.

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 domain param's flexible-input note ('an address on it, or its website URL') lives in the schema, and _corply_context is undocumented in both schema and description. The description contributes no parameter meaning and does not compensate for the uncovered nested context object.

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 ('Read and save the public DNS state of a domain') and constrains scope with 'without registering or changing it,' which implicitly rules out connect/register siblings. It doesn't name the closest alternatives (check_email_domain, get_email_domain), so an agent must still infer which inspection tool to pick.

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

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

The only usage context is 'authenticated active company access plus every prerequisite stated above' – a prerequisite pointer to text that isn't present here. There is no statement of when to choose this over check_email_domain or get_email_domain, no exclusions, and no scenario guidance.

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

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

Annotations declare readOnlyHint=false, destructiveHint=true, openWorldHint=true, and the description supplements this with delivery behavior (links go directly to each cofounder, shown here only on email failure), idempotency guidance, and a confirmation boundary. Much of this is generic template text (canonicality, retry-key boilerplate) that is not specific to this action, but the concrete delivery and failure semantics add real value.

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 key prerequisite and trigger are front-loaded in the first sentences, but the body includes several boilerplate sections (Canonicality, Idempotency, Confirmation boundary) that read as reusable template text rather than tool-specific guidance, inflating length.

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-type, high-impact email action with no output schema, the description covers prerequisites, auth requirements, delivery/failure behavior, idempotency, and confirmation boundary. The notable omission is any explanation of the input parameters.

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

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

Schema description coverage is 0% with two parameters (formationId required, plus the nested _corply_context). The description never explains what formationId identifies or what _corply_context is for, so it does not compensate for the documentation gap in 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+resource: emails each OTHER listed founder's pending review-and-sign link after documents are generated. It explicitly distinguishes itself from invite_member (which 'resends') and clarifies it 'never creates or refreshes membership invitations', so an agent can route correctly.

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 trigger condition ('Only run when the lead explicitly asks'), a prerequisite chain (fee must be PAID first via request_payment → await_payment, documents generated), and names the alternative path (invite_member). Usage is unambiguous.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true and openWorldHint=true, and the description adds substantial non-annotated context: the invitation is independent of name checks, documents, payment and signatures, the invitee joins from their own Corply session, an authenticated active company is prerequisite, and it states an idempotency/retry policy and a confirmation boundary. The internally inconsistent 'No separate confirmation is needed' versus 'obtain fresh, explicit user confirmation before calling' muddies the confirmation requirement.

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, resend case and revoke_invite routing are front-loaded, which is good. But the tail is dominated by generic boilerplate (Canonicality, Idempotency, Confirmation boundary) that reads as templated policy rather than tool-specific information, inflating the description without adding signal.

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 mutation with no output schema and 0% parameter coverage, the description covers prerequisites, side-effect independence and the resend path reasonably well. It still leaves the role parameter and _corply_context undocumented, and there is no statement of what the tool returns or what state changes for the invitee.

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 largely does not. It mentions supplying companyId and implies email, but never enumerates or explains the five role values (founder/cofounder/counsel/advisor/observer) beyond a vague 'other roles', and the nested _corply_context object is not addressed at all.

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: 'Invite someone to the connected company by email, or resend an invitation.' It also narrows scope by noting that founders saved via save_application are already invited, which carves out part of the sibling space. It stops short of naming the close siblings (invite_cofounders, redeem_invite, approve_invited_identity), so differentiation is partial.

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

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

Gives clear usage context ('use this for resends and other roles') and an explicit alternative for the failure path: 'If an address is wrong, call revoke_invite.' That is real when-to-use and when-to-route-elsewhere guidance. It lacks an explicit when-not-to-use-this-tool clause against invite_cofounders, so it falls just 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=true and destructiveHint=false, but the description adds genuinely useful behavior: no taxpayer number is returned, IRS receipt is separate from Corply mailing, reads current server state, and safe to repeat. The confirmation-boundary sentence is boilerplate-heavy but does clarify no extra confirmation is needed.

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 purpose is correctly front-loaded in the first sentence, which is the strongest part. But the trailing Canonicality/Idempotency/Confirmation-boundary blocks read as a policy template stretched over a simple read and dilute the signal.

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 tool with no output schema, the description should describe what comes back, and it partially does (EIN responsible party, pending Form 8822-B changes, no taxpayer number). However the broken 'stated above' prerequisite and undocumented _corply_context leave gaps an agent would need to resolve elsewhere.

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

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

Schema description coverage is 0% and the description says nothing about companyId or the nested _corply_context object (id/receipt with dependentRequired). With so many sibling tools taking a company, how that identifier is interpreted here is 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: reads the current EIN responsible party plus pending Form 8822-B changes. That is concrete enough to distinguish it from the write-side sibling request_business_irs_change, though the description never names that sibling to make the contrast 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 only usage signal is 'Prerequisite: authenticated active company access plus every prerequisite stated above' — 'stated above' points at nothing in the description, so it is a dangling reference. There is no when-to-use vs request_business_irs_change guidance and no exclusions.

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

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

Annotations already declare readOnlyHint, destructiveHint=false, and closed-world behavior, so the bar is lower. The description still adds genuine context: idempotency ('safe to repeat') and canonicality ('reads current server state and does not manufacture company facts'). The confirmation-boundary sentence is partly useful but bloated with unrelated action categories (reversible save, link preparation, plan refresh), which dilutes it slightly.

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 purpose is front-loaded and the labeled sections (Prerequisite, Canonicality, Idempotency, Confirmation boundary) give structure, but the boilerplate tail enumerating unrelated action types is waste, and the 'every prerequisite stated above' clause is filler.

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

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

For a read-only tool with no output schema, the behavioral envelope is adequately covered. However, with 0% schema coverage on two parameters—one a nested context object—an agent lacks the parameter detail needed to invoke it correctly, leaving a meaningful gap.