corply

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

Beyond annotations (readOnlyHint=false, destructiveHint=false), the description adds rich behavioral context: records are non-verified assertions, returns a refreshed get_company_briefing, requests additional documents, and explains idempotency rules (safe retries with same key, rejection of different inputs). It also clarifies that no filing, payment, or verification occurs, which is critical for agent decision-making.

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 verbose and contains some redundancy (e.g., 'Prerequisite: authenticated active organization access plus every prerequisite stated above' restates earlier points). While it front-loads the purpose, subsequent sentences could be streamlined. A more concise structure would improve quick comprehension.

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 no output schema, the description covers the tool's input, behavior, side effects (refresh briefing, request documents), and safety profile. It also mentions canonicality and confirmation boundary. However, it could elaborate on error conditions or what exactly the returned get_company_briefing contains, leaving some ambiguity.

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 provides meaningful context for all parameters. It explicitly mentions that the tool records name (assertedName), jurisdiction, entityType, date (formationDate), and fileNumber. It also explains the companyId prerequisite and the idempotencyKey requirement. Though it does not detail constraints or formats (already in schema), it adds purpose-based understanding.

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

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

The description clearly states the tool's purpose: 'Attach an already-existing company without creating a Corply formation. Records name, jurisdiction, entity type, date, and file number as founder assertions—not verified facts—then returns a refreshed get_company_briefing result.' It uses specific verbs and resources, and distinguishes itself from creation tools and sibling tools like import_cap_table.

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

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

The description provides explicit usage guidance including prerequisites (active company-manager access, companyId when multiple companies, idempotencyKey), idempotency behavior, and confirmation boundaries. It states when no extra confirmation is needed. However, it could more directly contrast with sibling tools that record similar data (e.g., record_operating_fact) to fully differentiate use cases.

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?

Description contradicts annotation readOnlyHint=false by characterizing the tool as a 'read', causing inconsistency. Although behavioral details are provided, the contradiction warrants a score of 1 per evaluation rules.

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

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

Description is overly long with generic boilerplate at the end about canonicality, idempotency, and confirmation boundary that is not tool-specific. Could be trimmed for 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?

Despite lacking output schema, the description explains return values (status), loop behavior, and responses for each status. Prerequisites and sibling tool restrictions are covered, making it fairly 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 50% (one parameter described). The description adds no additional parameter meaning beyond what the schema provides, and mentions max wait time but not explicitly tied to maxWaitSeconds parameter.

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

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

The description clearly states the tool waits for payment to land and returns status. It distinguishes from siblings by specifying not to call other tools before payment is complete, and what to do for different statuses.

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 instructs to call in a loop until 'paid', and when to use request_payment for 'expired' or 'unpaid'. Clearly states prerequisites and when not to use 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?

The description adds behavioral context beyond annotations: results are advisory, no confirmation needed, previously rejected names skip provider calls, and the mandatory Delaware check is done separately. This supplements the openWorldHint and destructiveHint annotations without 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 description is verbose and includes redundant phrases like 'plus every prerequisite stated above' and a final sentence about confirmation boundary that reads like boilerplate. It could be more concise.

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

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

The description covers key aspects: advisory nature, provider behavior, prerequisite, and idempotency hint, but lacks details on return value semantics (available=true/false/null) and what happens on invalid formationId. No output schema exists to fill 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?

With 0% schema description coverage, the description partially compensates by explaining to pass selectedName exactly and preserve order for similarNames, but does not clarify formationId beyond its UUID format. The meaning of similarNames is implied but not explicitly defined.

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

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

The description clearly states the tool checks the formation's saved company name and up to five alternatives through OpenSOSData. It specifies the verb 'check' and the resource 'company names', but does not differentiate from sibling tools like 'resolve_company_plan' or 'validate_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?

The description advises to pass selectedName exactly and preserve alternative order, and notes that previously rejected names return false without a new provider call. However, it does not explicitly state when to use this tool over alternatives or provide when-not-to-use 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 provide readOnlyHint=false, and description adds behavioral traits: creates immutable legal documents, idempotent within canonical facts, requires confirmation before each call, and describes phase-dependent output. 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?

Description is lengthy with multiple sentences covering many details. It front-loads the key concept but includes verbose explanations of phases, prerequisites, and behavioral notes. Could be more streamlined without losing essential 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?

Covers prerequisites, phase-dependent behavior, idempotency, confirmation requirement, and post-call actions (refresh get_company_briefing). Lacks description of output format since no output schema exists, but otherwise complete for a complex legal document tool.

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

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

Only one parameter (formationId) with 0% schema description coverage. Description does not explicitly define formationId but implies its role through context about formation phases. Adds moderate value beyond schema, but could be more explicit.

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

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

Description clearly states it's a 'phase-aware immutable generation' tool for creating legal documents like Certificate of Incorporation, Bylaws, etc. It distinguishes itself by describing the specific documents produced at different stages, making the purpose unmistakable.

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 states when to call based on formation status ('ready' vs 'formed'), prerequisites (authenticated organization access), and conditions like idempotency and confirmation before every call. Does not explicitly contrast with sibling tools, but given the unique nature, it's clear when to use.

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. Description adds context: reads current state, safe to repeat, no confirmation needed. No contradiction and provides additional nuance 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?

Description is front-loaded with the main purpose and includes several concise behavioral notes. Slightly verbose but each sentence adds value. Could be trimmed slightly without loss.

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?

Covers return value and behavioral aspects well given annotations. However, missing explanation for the sole parameter (companyId) and no output schema to clarify the response structure, leaving gaps for a tool with only one undocumented 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 has one parameter (companyId) with 0% description coverage. Description does not explain what companyId is or how to provide it. Fails to compensate for the lack of schema descriptions.

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

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

Description clearly states it returns the company's live cap table with specific fields (security type, shares, price paid, ownership %, total shares issued). It distinguishes itself from siblings like import_cap_table by emphasizing it reads current server state without manufacturing facts.

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 mentions prerequisites (authenticated active organization access) and provides behavioral guidelines (idempotency, confirmation boundary). Does not explicitly exclude alternative tools but context implies when to use this read operation vs import.

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?

Disclosures include no external side effect, no confirmation needed for read/reversible save, and canonicality. However, the description is somewhat contradictory regarding materializing a plan, and it repeats prerequisites. Annotations do not contradict, but the description could be clearer.

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 overly verbose, with repeated phrases (e.g., 'Prerequisite:' appears twice) and a rambling structure. It could be condensed to a few clear sentences.

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

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

With no output schema and low parameter coverage, the description fails to explain what the tool returns or the meaning of itemLimit and questionLimit. It is incomplete for an agent to use effectively.

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 description only mentions companyId in context of multiple companies (pass companyId and never guess), but provides no explanation for itemLimit or questionLimit. With 0% schema coverage, this is insufficient.

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

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

The description clearly states it returns a company briefing with specific context, and positions itself as the first tool for company-specific work. It distinguishes from siblings by being the initial entry point, though the extensive list could be more succinct.

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 prerequisites (authenticated active organization member), warns against guessing companyId, mentions idempotency and confirmation boundaries, and indicates when to refresh. However, it does not explicitly state when to avoid using this tool.

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

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

Annotations already indicate read-only and non-destructive behavior. The description adds value by specifying canonicality (reads server state, does not manufacture facts), idempotency (safe to repeat), and confirmation boundary (no extra confirmation needed). 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 somewhat verbose with formal terms like 'Canonicality', 'Idempotency', and 'Confirmation boundary'. While front-loaded with the main purpose, the additional detail could be more concise.

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

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

Given no parameters, read-only annotations, and no output schema, the description sufficiently covers return values, prerequisite, and alternative tool. It provides enough context for a simple read operation.

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

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

There are no parameters, and schema coverage is 100%. The description adds value by specifying what is returned (organization and company identities), which is relevant beyond the schema. Baseline for 0 params is 4, and this is met.

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

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

The description clearly states the tool returns 'organization and company identities' and is a 'compatibility read'. It distinguishes from sibling 'get_company_briefing' by recommending that tool for company-specific work, so purpose is specific and 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 explicitly advises to prefer 'get_company_briefing' for company-specific work and mentions a prerequisite (authenticated active organization access). However, it references 'every prerequisite stated above' which is vague and may not exist in this context, slightly reducing clarity.

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 (readOnlyHint=true, destructiveHint=false) are supplemented with useful context: 'reads current server state', 'does not manufacture company facts', and 'safe to repeat' (idempotency). The 'Confirmation boundary' mention is confusing but overall adds transparency 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 description is overly long with verbose 'principles' (Prerequisite, Canonicality, Idempotency, Confirmation boundary) that could be shortened or omitted. While it front-loads return fields, the extra text reduces clarity and brevity.

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

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

No output schema exists, but the description lists returned fields (checklist, pendingSignatures, etc.), which is helpful. However, it fails to document parameters or clarify prerequisites, leaving gaps for a tool with 2 parameters and no schema descriptions.

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 the description provides no explanation for the two parameters (companyId, formationId). Agents have no guidance on what values are expected or how they relate to the tool's function. This is a critical 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?

Clearly states it 'Return the formation status for a company' and lists specific fields (checklist, payment block, pendingSignatures, etc.). The verb 'Return' and resource 'formation status' are clear, but it does not explicitly differentiate from sibling tools like get_company_briefing, which may overlap.

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

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

No explicit guidance on when to use this tool versus its many siblings (e.g., get_company_briefing, get_org). Mentions prerequisites vaguely ('authenticated active organization access plus every prerequisite stated above') but no when-not-to-use or 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?

Goes beyond annotations by detailing one-way import (Corply becomes source of truth), full replacement of existing cap table, and owner/founder-only access. No contradictions 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?

Description is structured with clear sections: purpose, usage, prerequisites, post-call actions, idempotency, confirmation. Each sentence adds value, though slightly verbose with boilerplate-like terms.

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?

Covers purpose, usage flow, permissions, post-call refresh, and retry guidance. Lacks explanation of source enum, companyId parameter, and return structure, but given destructive nature and no output schema, it provides sufficient guardrails.

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 20%, but the tool description only adds context for 'csv' and 'confirm' parameters. Other params (source, companyId, idempotencyKey) are not explained, leaving gaps for the agent.

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

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

The description clearly states the tool imports a cap table from Carta/Pulley CSV exports, making Corply the system of record. It distinguishes from read-only tools like get_cap_table and specifies owner/founder restriction.

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 instructs to call with confirm:false first for preview, then confirm to replace. Provides prerequisites, post-call refresh guidance, idempotency handling, and confirmation boundary. Clearly distinguishes preview from destructive commit.

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?

Discloses it is a compatibility action that emails links, never creates membership invitations, and requires refreshed state after use. Annotations are consistent (destructiveHint, readOnlyHint=false) and description adds context 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 description is dense but well-structured, front-loading the critical prerequisite and action. Minor redundancy (e.g., 'every prerequisite stated above') could be trimmed, but overall efficient.

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

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

For a single-parameter tool with no output schema, the description covers prerequisites, action, exclusions, side effects, and post-use refresh, providing a complete contextual picture.

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 the description provides no explicit explanation of the formationId parameter, though context implies it identifies the formation. The parameter semantics are implied but not 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?

The description clearly states the tool emails a review-and-sign link to other listed founders after documents are generated, and distinguishes it from invite_member which handles membership invitations.

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 states prerequisites (fee paid), when to use (after documents generated, only when lead asks), and when not to (use invite_member earlier). Also includes idempotency and confirmation boundary 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?

The description adds behavioral context beyond annotations, such as the need to refresh 'get_company_briefing' after material change and idempotency handling. The destructive hint is reinforced with a confirmation boundary instruction.

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 verbose, containing generic boilerplate about prerequisites, canonicality, and idempotency that could be externalized. The core purpose is buried among general instructions, reducing 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?

While the description covers some behavioral aspects and refreshes-needed after effect, it lacks explanation of return values (no output schema) and detailed side effects. Given the tool's destructive nature, more context on what happens after would improve 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 parameter descriptions are absent (0% coverage), and the tool description does not explain the parameters (email, role, companyId) beyond what is implied by their names. This forces the agent to infer meaning, risking misuse.

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

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

The description clearly states the action ('Invite a cofounder to this organization by email') and specifies when to call. However, it does not differentiate from the sibling tool 'invite_cofounders', which could be confusing for an AI agent deciding which tool to use.

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

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

The description provides some usage context, such as calling only after explicit confirmation and that the invitation is independent of other processes. But it lacks explicit guidance on when not to use this tool or direct comparison with siblings like 'invite_cofounders'.

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 indicate destructiveHint: true, meaning mutation. The description adds crucial behavioral context: owner/operator-only restriction, audit tombstone on revocation, idempotency considerations, and confirmation boundary. 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 dense single paragraph that front-loads the core action and then adds important details. While it is packed with information, it is not overly verbose. The structure is logical, moving from purpose to usage to prerequisites.

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 complexity (8 parameters, destructive action) and lack of output schema, the description covers the necessary context: what it does, when to use, parameter semantics, prerequisites, and lifecycle behavior. It is sufficiently complete for an agent to invoke correctly.

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

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

Schema coverage is 88%, so baseline is 3. The description adds value by restating and clarifying key constraints: reason requires specific purpose, grantId is required for revoke, companyId can be omitted if one company, dataClass is required for grant and one class at a time, expiresAt future and ≤90 days, granteeUserId must be active member. This helps the agent select correct values beyond the schema.

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

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

The description clearly states it grants or revokes expiring access to one restricted operating-data class, specifying it's owner/operator-only. The verb 'manage' combined with the details of grant/revoke leaves no ambiguity about what the tool does, and it distinguishes itself from siblings by focusing on access management.

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

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

The description provides explicit guidance on when to use: narrow subject and class, explain business purpose, cap at 90 days, revoke immediately when engagement ends. It also mentions prerequisites. However, it does not explicitly compare with sibling tools or state when not to use, which would improve it further.

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 context beyond annotations: status becomes 'pending review', team verifies, includes idempotency and confirmation boundary guidance. However, generic boilerplate reduces impact.

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?

Core purpose is clear but description includes verbose generic sections on canonicality, idempotency, and confirmation that are not specific to 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?

Lacks return value details and side effects beyond status change; but mentions refreshing get_company_briefing. Adequate but not thorough.

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 description only mentions 'stepKey' implicitly and 'optional note' without explaining format or examples, leaving gaps for the agent.

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 specifies reporting a post-incorporation task as done for tasks assigned to the founder, distinguishing it from siblings like 'record_existing_completion' which may cover other task types.

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

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

Clearly states prerequisite (authenticated active organization access) and scope (only founder's tasks), but does not explicitly exclude alternative tools or scenarios.

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 indicate mutation and destructiveness. Description adds context about side effects ('material change'), idempotency, and need for user confirmation, but includes generic prerequisites that add little 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?

First sentence is concise, but subsequent sentences contain generic boilerplate (prerequisites, canonicality, idempotency, confirmation boundary) that could be streamlined. Less is more.

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?

Covers usage conditions and confirmation, but lacks explanation of parameters and what happens if the cofounder already signed. Could be more complete for a simple tool.

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

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

Schema coverage is 0%, so description must explain parameters. It does not describe email or formationId, failing to add meaning beyond the schema. Usage hint is only implicit.

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

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

The description clearly states the action: resend signature reminder email, specifies the target (cofounder who hasn't signed), and includes a condition (only when lead asks). This distinguishes it from sibling tools like request_signature.

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 explicit when-to-use: 'Only when the lead asks'. Lists prerequisites, idempotency guidelines, and confirmation boundary. Offers clear alternatives by referencing get_company_briefing for state refresh.

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 canonicality, idempotency, and confirmation boundary details beyond annotations (readOnlyHint, destructiveHint). Describes reads as non-fabricating and safe to repeat, but lacks specifics on return format or error handling.

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?

Contains verbose terms like 'Canonicality' and 'Confirmation boundary' that add jargon without clarity. Could be trimmed to fewer sentences while retaining key 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?

No output schema and description omits return values. Does not mention pagination, result structure, or what happens when no facts match. Behavioral traits covered but output omitted.

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 has 0% description coverage and description does not explain the 'query' or 'includeGlobal' parameters. No hints on expected format, defaults, or behavior.

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

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

Description states 'Search the organization's context memory + Corply reference KB for relevant facts', which is a clear verb+resource. Differentiates from 'remember' (which likely stores) but does not explicitly compare to other search-like 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?

Mentions prerequisite ('authenticated active organization access') but no guidance on when to use this tool vs siblings like 'remember' or 'get_company_briefing'. No when-not or explicit 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?

The description reveals several behavioral traits: requires idempotency key and attestation, routes claim to review, does not mark work completed immediately, and is a write operation. Annotations provide no safety hints (readOnlyHint=false), so the description adds significant context. However, there is a slight contradiction between 'immutable claim' and 'reversible save' in the confirmation boundary, reducing clarity.

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 dense paragraph packed with information. While it avoids fluff, the lack of structure (e.g., bullet points or sections) reduces readability. It could be more concise by separating guidelines from behavior.

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 high complexity (12 parameters, nested objects, no output schema), the description covers the high-level workflow and boundaries (review routing, not marking completed) but lacks parameter-level details and does not describe the response format. It provides a complete picture of tool purpose and usage intent but insufficient detail for an agent to correctly invoke all 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%, so the description must compensate. While it mentions key parameters (ruleId, ruleVersion, occurrenceKey, idempotencyKey, attestation), it provides no details on complex nested objects like source, evidence, provenance, or claimedOutcome. The description gives no format or constraint information, leaving gaps for an agent to guess parameter structure.

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

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

The description clearly states it records evidence of a completed materialized work occurrence outside Corply. It uses specific verbs ('record', 'pins') and identifies the resource. It implicitly distinguishes from sibling recording tools like record_operating_event or record_operating_evidence by specifying 'completion' and 'outside Corply'.

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

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

The description explicitly says when to use (recording evidence of completion outside Corply) and when not to use: 'use the normal fact and work-transition tools only after the returned review...'. It also mentions prerequisites (authenticated active organization access) and idempotency guidelines.

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 goes well beyond annotations (readOnlyHint=false, openWorldHint=false, destructiveHint=false) by detailing atomicity, rejection of scalar writes, evidence staging, idempotency ('obey the tool-specific retry key'), and post-mutation refresh (get_company_briefing). It also states the confirmation boundary. No contradictions 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 dense and informative, but could be more structured. Key information is front-loaded with the primary purpose. However, the long compound sentences and mix of behavioral notes and preconditions make it harder to parse quickly. Not overly concise, but all content is relevant.

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 complexity (18 params, 8 required, nested objects, no output schema), the description covers behavioral aspects well (atomicity, evidence flow, retry, idempotency) but lacks parameter-level details and does not describe return values. Schema coverage is moderate, so the description should have compensated more.

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

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

The input schema has 50% description coverage, leaving many parameters (e.g., confidence, provenance, trustLevel, effectiveFrom, effectiveTo) without schema explanations. The description adds no parameter semantics; it only mentions behavioral constraints. This is insufficient for a tool with 18 parameters, especially 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?

The description clearly states the tool's purpose: 'Atomically stage or promote one event occurrence's stable ID and mutable anchor fact.' It specifies the verb (stage/promote) and resource (event occurrence's stable ID and anchor fact). However, it does not explicitly distinguish from sibling tools like record_operating_fact or record_operating_evidence, though the evidence workflow is mentioned.

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

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

The description provides usage guidance: 'Use this for every fact named by an event rule; scalar writes are rejected' and explains the evidence-gated retry workflow. It mentions prerequisites and retry behavior. However, it does not explicitly name alternative tools when this tool should not be used, leaving some ambiguity.

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?

Discloses that the tool triggers plan resolution after recording, advises refreshing get_company_briefing after material change, discusses idempotency and retry strategy, and states the confirmation boundary. Annotations are consistent (destructiveHint=false, readOnlyHint=false) and description adds valuable behavioral context 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 description is relatively long but structured: it front-loads the main action and then covers alternatives, prerequisites, side effects, and boundaries. Every sentence adds necessary information, though some detail could be streamlined. It avoids repetition of schema descriptions.

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 13 parameters (4 required), no output schema, and complex domain, the description provides high-level workflow, integration with sibling tools, side effects, and idempotency guidance. It does not detail return values but that is acceptable without output schema. Covers most what an agent needs to use 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 69%, so baseline is 3. The description adds value by explaining how parameters like filePath/fileHash are obtained from upload, and that factId links evidence to a fact. For a mutation tool with many parameters, this contextualization helps agents use parameters correctly.

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

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

The description clearly states the tool's purpose: 'Record a company-owned evidence artifact, then freshly resolve the plan.' It uses specific verb and resource, and distinguishes from sibling tools like upload_operating_evidence and submit_operating_fact_evidence by explaining when to use each.

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 explicit when-to-use and when-not-to-use guidance: for new files call upload_operating_evidence, for founder-uploaded documents use submit_operating_fact_evidence, only operator can promote facts, professional determinations require credentials. Also mentions prerequisites and alternative workflows.

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 discloses important behavioral traits beyond annotations, such as idempotency guidance ('obey retry key or inspect refreshed state'), canonicality ('refresh get_company_briefing after material change'), and confirmation boundaries. No contradiction with readOnlyHint=false or destructiveHint=false.

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 dense and covers multiple topics in a single paragraph, which is functional but not optimally structured. Key information is front-loaded, but the inclusion of retry and boundary details without clear separation reduces 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?

Given the tool's complexity (17 parameters, 7 required, no output schema), the description covers prerequisites, behavioral traits, and restricted facts. However, it omits description of the return value or error conditions, which is a notable gap for a mutating tool without output schema.

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

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

With 53% schema description coverage, the description adds some value by providing examples (factKey like 'entity.formed') and warnings about values (e.g., never infer restricted facts). However, much of the parameter intent is already covered in the schema, and the description does not significantly enhance understanding for undocumented parameters.

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

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

The description clearly states it records a typed, versioned fact and resolves the plan, using specific verbs and resources. It distinguishes from siblings like record_operating_event by focusing on facts and mentioning canonicality with confirmation, but does not explicitly contrast with similar 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?

The description provides some usage context, such as not recording restricted facts (immigration, tax/legal) and prerequisites. However, it lacks explicit guidance on when to use this tool vs alternatives like record_operating_evidence or when not to use 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?

The description discloses behavioral traits beyond annotations, such as idempotency ('obey the tool-specific retry key'), confirmation boundary ('obtain fresh, explicit user confirmation before calling'), and canonicality ('refresh get_company_briefing after material change'). The destructiveHint:true annotation is confirmed by the description's warning to not set esignConsent without affirmative signing.

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 front-loaded with the purpose and detailed guidelines, but it is somewhat verbose with redundant phrases (e.g., 'Prerequisite: authenticated active organization access plus every prerequisite stated above'). Every sentence adds value, but tightening could improve clarity.

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 (4 required params, destructive action, no output schema), the description is remarkably complete. It covers prerequisites, call timing, idempotency, confirmation, and post-call actions. The context signals (high parameter count, no enums) are fully addressed.

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?

Despite 0% schema description coverage, the description adds meaning for two of four parameters: it explains that 'signatureId' should correspond to a pending signature and that 'esignConsent' must only be set when the signer affirmatively signed. However, 'signedLegalName' and 'contentHash' are not defined beyond the schema, leaving a gap for an agent.

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

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

The description clearly identifies the tool's purpose: 'Record a binding e-signature (full ESIGN/UETA audit bundle)'. It uses a specific verb ('record') and resource ('e-signature'), and the detailed context distinguishes it from siblings like 'request_signature' and 'nudge_signer'.

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

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

The description provides explicit usage guidelines, including a 'CALLER GATE' section that specifies when to call ('only after the actual signer... has been shown THIS specific document'), when not to call ('never act on standing/blanket/prior-session consent'), and prerequisites ('authenticated active organization access'). It also states to call once per pending signatureId.

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 discloses several behavioral traits beyond annotations: joining switches active organization, requires fresh user confirmation, invokes a shared backend action with a need to refresh get_company_briefing, and idempotency rules. No contradiction with annotations (readOnlyHint=false, destructiveHint=false).

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 starts with the core purpose and then adds necessary behavioral and usage details. Each sentence adds value, though some meta-instructions (prerequisites, canonicality, etc.) slightly increase length. Appropriate for the tool's complexity.

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 one parameter and no output schema, the description covers purpose, usage guidelines, behavioral traits, and confirmation. The only gap is parameter semantics (joinCode). Overall, it is complete enough for an agent to use correctly.

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

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

The description mentions 'invite join code' but does not describe the joinCode parameter's format, constraints, or usage beyond that. With 0% schema description coverage, the description should compensate but does not provide sufficient semantic detail.

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

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

The description clearly states 'Join an organization with an invite join code,' identifying the verb (join) and resource (organization via invite code). This distinguishes it from sibling tools like invite_cofounders and invite_member, which send invites rather than redeem 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 description includes explicit usage guidance: ask user to confirm first, joining switches active organization, prerequisites are required, and canonicality/idempotency/confirmation boundaries. It lacks explicit mention of when not to use this tool versus alternatives, but the context is clear.

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

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

Description adds value beyond annotations by clarifying it's a write operation ('reversible save'), not destructive, and needs a refresh of 'get_company_briefing' after changes. It also mentions idempotency and retry behavior. 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?

Description is verbose and includes cryptic phrases like 'plus every prerequisite stated above' (no prerequisites stated in description) and 'Canonicality: invokes the shared backend action'. It is not front-loaded or well-structured for quick understanding.

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 importance (persisting durable data), the description should cover return values, success/failure behavior, and prerequisites more clearly. It mentions side effects but lacks completeness. Output schema is absent, so description should compensate more.

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 has one parameter 'text' with no description (0% coverage). Description only implies 'the fact or decision to persist' but does not explicitly explain the parameter's meaning, format, or constraints. With low schema coverage, description fails to compensate adequately.

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

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

Description clearly states verb 'persist' and resource 'decision/fact into organization's context memory'. It provides a clear purpose but does not explicitly differentiate from sibling tools like 'record_operating_fact' or 'recall', though 'recall' likely retrieves.

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?

Only a vague prerequisite 'authenticated active organization access plus every prerequisite stated above' is mentioned. No guidance on when to use this tool versus alternatives like 'record_operating_fact' or 'recall'. Missing when-not or context for 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 already declare readOnlyHint=false, openWorldHint=true, destructiveHint=false. The description adds valuable context beyond them: it creates/reuses a link, shows checkoutUrl to the founder, is safe to re-call (reuses session), and never re-charges. No contradictions 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 relatively long with boilerplate sections like 'Canonicality', 'Idempotency', 'Confirmation boundary' that add generic but not tool-specific value. It could be more concise while retaining essential 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?

The description covers the main behavior, return value (checkoutUrl), side effects (reuse session), prerequisites, and post-call action (refresh get_company_briefing). For a tool with one parameter and no output schema, this is reasonably complete for an agent to use correctly.

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

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

The schema has 0% description coverage for the single required parameter 'formationId'. The description does not explain what 'formationId' represents or how to obtain it, leaving the agent to guess. The description should have clarified this parameter's meaning.

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

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

The description clearly states the tool creates or reuses a Stripe Checkout link for the one-time Corply incorporation fee ($600). It uses specific verbs ('create', 'reuse') and resource ('Stripe Checkout link'), and distinguishes from sibling tools by noting it's mandatory before signing and only for lead founders.

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

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

The description provides clear usage context: mandatory before signing, only lead founder pays once, safe to re-call, and prerequisites (authenticated active organization access). However, it does not explicitly contrast with sibling tools like 'await_payment' or 'request_signature'.

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 beyond annotations by describing idempotency (reuses pending requests), return format (disclaimer + review link), and canonicality (refresh company briefing). No contradiction with readOnlyHint=false.

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 key prerequisite, but the description is lengthy with extraneous details like canonicality and idempotency instructions that could be streamlined.

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?

Covers return format, idempotency, and prerequisites despite no output schema. Lacks error handling details for invalid formationId, but overall sufficient for agent usage.

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 description does not explain the formationId parameter. The only context is the tool's purpose, but the parameter's meaning is inferred rather than defined.

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?

Clearly states the tool requests signatures for incorporation documents with phase-aware behavior. Distinguishes from siblings like generate_documents and nudge_signer by detailing the document lifecycle.

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 states prerequisite (payment first), phase-dependency, and provides a specific when-not-to-use (83(b) elections handled separately). Includes confirmation boundary instruction.

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 are limited (readOnlyHint=false, destructiveHint=false, openWorldHint=false), so the description adds significant value: it explains that the lifecycle is always running, provides idempotency guidance, and clarifies that no additional confirmation is needed for read/reversible actions. This goes beyond annotations without contradicting them.

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 lengthy with multiple sentences covering purpose, prerequisites, boundaries, idempotency, and confirmation. While front-loaded with the main action, it is not concise; every sentence earns its place but could be more structured (e.g., bullet points). Adequate but not exemplary.

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, yet the description does not explain what the tool returns (e.g., items per section, missing-fact questions). It mentions side effects (refresh get_company_briefing) but omits return structure, which is critical for an agent. Incomplete for a tool of this complexity.

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

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

Schema coverage is 100% with descriptions on all three parameters, so baseline is 3. The description does not add parameter-specific details beyond the schema, but it does mention the concept of 'actionable/blocked/waiting sections' and 'missing-fact questions' implicitly through the parameter descriptions. No extra value added.

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

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

The description clearly states the tool 'resolve and materialize the company's current operating graph,' which is a specific verb+resource. However, it does not explicitly differentiate from sibling tools like 'transition_operating_work_item' or 'upsert_operating_subject', so it loses a point for lack of distinction.

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 includes prerequisites (authenticated active organization access) and some boundaries (honor evidence, signature, etc.), but it does not explicitly state when to use this tool versus alternatives or when not to use it. The context is clear but without exclusions or explicit comparison.

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 indicate this is neither read-only nor destructive. The description adds crucial behavioral details: deep-merge semantics (partial payload never wipes sections), return shape ({ formationId, nextStep }), reversible nature, and idempotency advice. 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 front-loaded with the core behavior and includes additional helpful notes (prerequisites, canonicality, idempotency, confirmation boundary). Each sentence adds value, though it could be slightly more concise without losing 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?

Given the complex nested schema, no output schema, and sparse annotations, the description covers key aspects: behavior, prerequisites, post-action recommendation, and idempotency. It adequately informs the agent about when and how to use the tool, though some parameter details rely on the schema.

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

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

The schema has 2 parameters with 50% description coverage. The description provides overall context (deep-merge upsert of formation application) but does not detail individual fields beyond what the schema already states. The schema itself has many nested fields with some descriptions. A baseline of 3 is appropriate given the coverage and the description's partial 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?

The description clearly states the verb (upsert), resource (structured formation application), and key behavior (deep-merge incremental save). It distinguishes from full-replacement operations by emphasizing that partial payloads never wipe untouched sections.

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

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

The description provides explicit prerequisites (authenticated active organization access), canonicality advice (refresh get_company_briefing after change), and idempotency guidance. It also includes a confirmation boundary note. However, it does not explicitly contrast with alternative tools like 'validate_application' or 'submit_for_formation'.

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 significant behavioral context beyond annotations: canonicality (refresh get_company_briefing), idempotency guidance, and confirmation boundary. It also clarifies it does not file, which is not obvious. No 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 description is densely packed with useful information but is not overly verbose. It front-loads the key prerequisite and then adds structured notes on canonicality, idempotency, and confirmation. Minor redundancy in the prerequisites list.

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 simple input schema and no output schema, the description covers prerequisites, behavioral notes, and confirmation. However, it omits details on success/failure indications or return values, leaving the agent unsure about the tool's outcome.

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 single parameter 'formationId' is not described in the text. While the purpose implies it identifies the formation, the description adds no details about format, validation, or semantics, leaving the agent to guess.

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

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

The description clearly states the tool's action: 'Hand the fully-signed formation to the human filing pipeline.' It also explicitly says 'Does NOT file with Delaware,' distinguishing it from a potentially confusing sibling and providing precise scope.

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

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

The description gives explicit prerequisites: 'Requires the incorporation fee to be PAID first (request_payment → await_payment)' and 'Prerequisite: authenticated active organization access plus every prerequisite stated above.' It also includes a confirmation boundary, guiding when to call.

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

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

The description adds behavioral context beyond annotations: it clarifies the submission is not canonical, requires operator approval, and is idempotent. It also specifies that no additional confirmation is needed. These details expand on the basic destructiveHint=false annotation without 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 description is front-loaded with the main action but contains verbose jargon like 'stages the exact typed assertion' and 'binds the server-verified immutable artifact'. While comprehensive, it could be trimmed for better 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?

The description covers the workflow stages, prerequisites, and idempotency, but lacks details on output or response interpretation. Without an output schema, the description should clarify what the caller can expect after submission, which is absent.

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

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

With 0% schema description coverage for 10 required parameters, the description only generally mentions filePath/fileHash must come from upload_operating_evidence and alludes to value and title, but fails to individually explain each parameter's purpose or constraints.

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

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

The description clearly states it submits a founder-provided document for an evidence-confirmed operating fact and explains the staging, binding, and review-claim creation process. It distinguishes itself from sibling tools like record_operating_fact and record_operating_evidence by emphasizing the evidence-confirmed and review-claim nature.

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

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

The description provides explicit prerequisites (filePath/fileHash from upload_operating_evidence) and explains that submission does not make the fact canonical, requiring operator approval. It mentions idempotency and confirmation boundary but lacks explicit comparison to alternatives like record_operating_fact.

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?

Description adds significant context beyond annotations: constraints on completion (evidence must cover requirements), truthful evidence requirement, idempotency rules, post-action refresh guidance, and confirmation requirement. Annotations only flag destructiveHint=true; description elaborates extensively.

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?

Description is fairly concise given the amount of content. It is structured with clear sections (prerequisites, canonicality, idempotency, confirmation). However, some sentences are dense and could be slightly trimmed without losing 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?

For a destructive tool with 9 parameters and no output schema, the description covers behavior, preconditions, post-conditions, failure conditions, idempotency, and confirmation. It fully addresses the tool's complexity without needing an output schema.

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

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

Schema coverage is only 44%, but the description does not explain individual parameters beyond mentioning workItemId and evidenceEventIds in context. It relies on schema descriptions, which are incomplete. Could add more parameter-specific guidance.

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 starts with a clear verb+resource: 'Transition one materialized work occurrence by workItemId, then freshly resolve the company plan.' It distinguishes from siblings like 'resolve_company_plan' and 'record_operating_event' by specifying it transitions a work item and immediately resolves the plan.

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 explicit prerequisites ('authenticated active organization access') and a confirmation boundary ('obtain fresh, explicit user confirmation before calling'). Also gives idempotency guidance. However, it does not explicitly compare to sibling tools or state when not to use this tool.

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

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

Provides some behavioral details (store, return SHA-256) but includes contradictory language ('read, reversible save') that conflicts with annotations (readOnlyHint=false). Also lacks clarity on idempotency and error conditions.

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?

Overly verbose with boilerplate sentences (e.g., 'Canonicality: invokes the shared backend action...'). Core purpose is in first sentence, but unnecessary details bloat the 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?

Lacks details on return value (SHA-256) beyond mentioning it, size limits (only alternative for large files), and error handling. The description tries to cover multiple aspects but is confusing.

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

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

Only 50% schema coverage; description adds value for dataBase64 (base64 bytes) but fails to explain fileName and contentType. Overall minimal addition beyond 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 description clearly states the tool stores caller-supplied evidence bytes and returns a SHA-256, distinguishing it from record_operating_evidence. However, the purpose is buried in verbose text.

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 states when to use (client has actual base64 bytes) and provides an alternative for large files (POST /operating/evidence/upload). Also mentions prerequisites.

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

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

It discloses that this is a create/update operation (mutation), triggers plan refresh, is idempotent with retry guidance, and requires no extra confirmation. Annotations (readOnlyHint: false, destructiveHint: false) are consistent with a reversible save operation.

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 somewhat long but each sentence adds value. It is front-loaded with the core purpose. Could be slightly more concise but is well-structured overall.

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 9 parameters, nested objects, and no output schema, the description covers prerequisites, idempotency, and confirmation boundary. However, it omits what the tool returns, which is needed since there is no output schema.

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

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

Schema coverage is 67%. The description adds context: attributes are limited to integration linkage, externalKey should be stable, and subjectType values are listed. However, it does not supplement low-coverage parameters like companyId or linkedUserId.

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

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

The description clearly states 'Create or update one durable company-owned subject' and lists all subject types. It differentiates from record_operating_fact by noting that decision facts should be stored there, not as opaque attributes.

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

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

The description provides usage guidance: use a stable externalKey, store facts via record_operating_fact, and never fabricate personal data. It mentions prerequisites but does not explicitly list alternatives for when to use this tool versus siblings like record_operating_evidence.

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 indicate readOnlyHint=false and destructiveHint=false. The description adds behavioral context: it promotes the formation to 'ready' and returns the canonical next step. It also mentions it invokes a shared backend action, which is useful. However, generic statements about retry keys and confirmation boundaries seem templated and may not apply.

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 verbose with redundant boilerplate (e.g., 'Canonicality', 'Idempotency', 'Confirmation boundary'). The first sentence is effective, but the rest adds little value and should be removed or tailored.

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, so the description should explain return values. It mentions missing fields and next step but omits specifics. The single parameter lacks documentation. The generic prerequisites and idempotency instructions are not tool-specific and fail to fill 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% (no description for 'formationId'). The description does not explain the parameter's meaning, format, or how to obtain it. It only mentions the tool returns missing fields but fails to define the input.

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

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

The description clearly states the tool validates a formation application, returns missing fields as dotted paths, and promotes to 'ready'. This verb+resource combination is specific. However, the purpose is diluted by excessive generic boilerplate about prerequisites and idempotency.

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

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

No explicit guidance on when to use this tool versus siblings like 'save_application' or 'submit_for_formation'. The only prerequisite mentioned ('authenticated active organization access') is vague and not helpful for 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 already indicate read-only, non-destructive behavior. The description adds canonicality (reads current state), idempotency (safe to repeat), and confirmation boundary (no confirmation needed). These go 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 description is concise and front-loaded with the main purpose. It uses clear bullet points for additional info. Could be slightly more streamlined, but every sentence adds 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?

Given zero parameters, no output schema, and annotations covering safety, the description is complete. It covers identity resolution, pending invites, prerequisites, and behavioral traits.

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 are no parameters, so the description does not need to add parameter meaning. The baseline for 0 params is 4. The description mentions pendingInvites as part of the return, not a parameter, which is appropriate.

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

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

The description clearly states it returns the resolved caller identity (user + org). The verb 'return' and resource 'caller identity' are specific. The mention of pending invites adds nuance. No sibling tool serves the same purpose, so differentiation is inherent.

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

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

The description provides a specific scenario: if pendingInvites is non-empty, offer to join. It also notes the prerequisite of authenticated active organization access. However, it does not explicitly state when not to use the tool or compare to alternatives.

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