StackFast FractWin Expert Brain

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds valuable behavioral context by clarifying the packet is 'review-only' and explicitly listing external actions it does not perform, which helps the agent understand the tool's scope beyond the annotations.

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

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

The description is a single focused sentence that front-loads the core purpose and then adds the key behavioral boundary. Every phrase earns its place, with no redundant or filler content.

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

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

Given the simple parameter set, rich annotations, and presence of an output schema, the description is largely sufficient. The only notable gap is the lack of any explanation for tenant_id and the absence of routing guidance to the other AI Receptionist siblings, but the core call is well covered.

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 needed to compensate for the undocumented parameters. It mentions 'one AI Receptionist call', which loosely maps to call_id, but it provides no detail on tenant_id or the expected format/meaning of either parameter. The parameter names are somewhat self-explanatory, but the description does not add meaningful guidance 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 uses a specific verb and resource: 'Return a human-review callback packet for one AI Receptionist call.' It clearly scopes the tool to a single call and distinguishes it from sibling tools like ai_receptionist_review_queue and ai_receptionist_status by emphasizing the packet output rather than queue or status behavior.

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

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

The description implies usage: use this when you need a review-only callback packet for a specific AI Receptionist call. It explicitly states what the tool does not do ('does not send SMS, place calls, or reply to customers autonomously'), but it does not name alternatives or state when another AI Receptionist tool should be used instead.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds useful non-obvious context: results are masked/audit-safe identifiers only, and may include callback/A2P SMS status where present. This informs agents about output sensitivity without relying solely on annotations.

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

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

A single, front-loaded sentence covers the action, resource, purpose, and return-characteristic in compact form. Every clause contributes information, with no filler or redundancy.

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

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

For a simple read-only list tool with two optional parameters and an output schema, the description covers the core purpose, result masking, and included status types. Minor gaps remain: 'recent' is not quantified, tenant_id scoping is unstated, and pagination/defaults are not mentioned, but annotations and output schema reduce the burden.

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 needed to compensate by explaining limit and tenant_id semantics, but it does not mention either parameter. The schema's min/max for limit and type for tenant_id are visible, but the agent gets no guidance on how tenant_id scopes results or what the default limit behavior is.

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

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

The description states a specific verb ('List'), resource ('AI Receptionist call-loop receipts'), and audience ('for human review'), making it clear this is a queue/listing tool. It also adds distinguishing detail by mentioning callback and A2P-gated inbound SMS status, separating it from sibling packet/status 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 phrase 'for human review' implies when the tool is appropriate, but the description does not explicitly contrast it with siblings like ai_receptionist_callback_packet or ai_receptionist_status, nor does it state when not to use it. Usage context is clear but alternatives are not addressed.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds meaningful context beyond those annotations by specifying exactly what is read, that it is scoped to one call ID, and that only masked/status metadata is returned.

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

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

Two sentences, front-loaded with the action and scope, and every clause adds information. There is no filler or repetition of schema details.

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

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

With annotations covering the safety profile and an output schema present, the description covers the essential input scope and return limitation. The main remaining gap is the undocumented optional tenant_id parameter, but overall the description is sufficient for a simple read-only status tool.

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

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

Schema description coverage is 0%, so the description must compensate, but it only references the call ID concept instead of the parameter name or the optional tenant_id. call_id is inferable from 'AI Receptionist call ID', but tenant_id gets no explanation, leaving a clear semantic gap.

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

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

The description uses a specific verb ('Read') and precisely names the resources involved: the Desk ticket, CRM callback task, call-link receipt, and A2P-gated inbound SMS posture for a single AI Receptionist call ID. 'Returns masked/status metadata only' also differentiates this from broader or more detailed sibling 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 makes the usage context clear: use it when you need the status/masked metadata for one AI Receptionist call ID. It does not explicitly name alternatives, but the singular-call scope and 'status metadata only' limitation provide practical selection 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 aligns with readOnlyHint=true and adds useful non-obvious context: the artifact is tenant-scoped and the audit covers multiple specific domains. It does not contradict annotations and adds value beyond the read-only flag.

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

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

A single, dense sentence with no filler. The verb and scope are front-loaded, and the enumerated audit domains are compact and informative.

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 names the main data domains and the tool has an output schema, so return shape is externally covered. However, the identifier disambiguation between artifact_id and draft_id, and the role of the required tenant_id, are left unclear 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 description coverage is 0%, so the description must compensate, but it only says 'one tenant-scoped artifact.' It does not clarify the roles of draft_id versus artifact_id, whether one is required in addition to tenant_id, or how tenant_id scopes the lookup.

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

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

States a specific read operation with an explicit resource and scope: 'Read provenance, analyzer findings, gate status, approval state, usage, and export receipts for one tenant-scoped artifact.' The detailed data categories clearly distinguish it from sibling artifact_export, artifact_generate, artifact_refine, and artifact_save.

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 when-to-use guidance or alternatives are mentioned in the description. An agent can infer this is the audit/read counterpart to the artifact_* tools, but the description does not state when to choose this over audit_status or other artifact 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?

Annotation Contradiction: the description opens with 'Create' and describes producing an audited receipt, implying a state-changing operation, while the readOnlyHint annotation is true. The sentence about external publish does not resolve whether this tool writes an audit/export record; the schema's idempotency_key further suggests mutation. This is a serious inconsistency.

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

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

Two sentences, front-loaded with the main action, and no filler. Every clause earns its place.

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

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

With 8 parameters, nested objects, and 0% schema descriptions, the description leaves too much to inference: which ID to supply, what target_config contains, and what idempotency/approval fields mean. An output schema exists, but that only handles the return side, not call construction.

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

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

Schema description coverage is 0%, so the description must compensate for parameters. It only hints that artifact_id or draft_id corresponds to 'approved artifact or internal draft' and gives no semantics for target_config, idempotency_key, approval_event_id, format, or target beyond the enum names.

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

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

The description uses a specific verb and resource: 'Create an audited export receipt' and scopes it to 'an approved artifact or internal draft.' It also separates this from external publish, which helps distinguish it from publish/approval-related siblings, though it does not name them.

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

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

It clearly says the tool is for approved artifacts or internal drafts, and states external publish is out of scope and human-approved. It does not explicitly name alternatives like artifact_generate or artifact_save, but the use case is sufficiently bounded.

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 meaningful behavioral context beyond the readOnlyHint annotation by mentioning no-fabrication placeholders, analyzer provenance, MASK, brand status, and approval requirements. It does not contradict the annotation because generating a 'draft' suggests an in-memory result rather than a persistent change.

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

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

The description is a single front-loaded sentence with no filler, and the key action is stated immediately. However, the dense jargon such as MASK, analyzer provenance, and approval requirements is not explained, which slightly reduces overall 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?

For a 17-parameter tool with no parameter descriptions, this description is far too sparse. It omits when to generate versus refine or save, how format/lane/variant settings interact, and what MASK or approval requirements actually mean. The output schema covers return values, but the invocation and selection context remains incomplete.

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

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

With 17 parameters and 0% schema description coverage, the description needed to compensate heavily but does not. It vaguely signals tenant scoping and artifact type, but terms like MASK, analyzer provenance, and approval requirements do not map to any schema property, leaving the agent without useful parameter-level 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 clearly states the action ('Generate') and the resource ('governed, tenant-scoped artifact draft'), which distinguishes it from siblings like artifact_save, artifact_refine, and artifact_export. The word 'draft' helps differentiate it from persistence-oriented tools, though no alternative is named explicitly.

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

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

There is no guidance on when to use this tool versus artifact_refine, artifact_save, or other generation-related siblings. The description implies a draft-generation use case but never states when it should be preferred or what to do after generation.

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 readOnlyHint annotation already indicates the tool does not mutate state. The description goes beyond this by specifying the invariants it preserves: tenant boundary, provenance, MASK status, and approval posture. This is useful behavioral context about what will and won't change, though it does not cover errors, outputs, or side effects beyond that.

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

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

The description is a single, front-loaded sentence. It leads with the core action, 'Refine an existing artifact draft,' and each remaining clause adds meaningful constraints. There is no wasted text.

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

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

For an 11-parameter tool with zero schema description coverage and no parameter explanations, this short description is insufficient. It gives a high-level purpose but leaves the agent guessing about how lane, format, audience, source_context, new_source_context, and idempotency_key should be used. The output schema helps with return shape, but not with call construction.

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

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

Schema description coverage is 0%, and the description does not explain any of the 11 parameters. The agent is left to infer meaning from parameter names alone. Even key parameters like refinement_instruction, draft_id, idempotency_key, and new_source_context are not described or connected to the tool's 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?

The description states a specific verb and resource: 'Refine an existing artifact draft.' It also names the key behavioral constraints (preserving tenant boundary, provenance, MASK status, approval posture), which distinguishes it from sibling tools like artifact_generate (creating new drafts) and artifact_save (persisting drafts). An agent can tell what this tool does at a glance.

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

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

The phrase 'existing artifact draft' implies this tool is for revising drafts that already exist, as opposed to generating new ones. However, the description gives no explicit when-to-use/when-not-to-use guidance and does not name alternatives such as artifact_generate or artifact_save.

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 says 'Approve/save' and 'mark eligibility', which are write-like side effects, but the annotations declare readOnlyHint=true. This is a direct contradiction that misleads agents about whether the tool mutates state. The added 'Does not publish externally' is useful but cannot compensate for the fundamental inconsistency.

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

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

Two short sentences deliver the core purpose and a key behavioral boundary with no filler. Every clause earns its place and the most important action is front-loaded.

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 an output schema being present, the tool has seven parameters, no parameter documentation, and no reliable behavioral annotations. The description clarifies intent but omits side effects, parameter semantics, prerequisites, and how the learning-loop eligibility is recorded, making it insufficient for confident invocation.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining the seven parameters, but it explains almost none. It vaguely maps to tenant_id, draft_id, approved, and learning_scope through phrases like 'tenant-scoped' and 'learning-loop eligibility,' but leaves reuse_tags, idempotency_key, and approval_event_id completely unexplained.

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

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

The description states a clear action ('Approve/save an artifact') and a specific outcome ('mark tenant-scoped learning-loop eligibility'), which distinguishes it from artifact_generate, artifact_export, and artifact_refine. The 'Does not publish externally' phrase adds a boundary that further clarifies its role, though 'save' is slightly generic.

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

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

The description implies this tool is for internal, tenant-scoped save/approval workflows and explicitly says it does not publish externally, giving some usage boundary. However, it does not name sibling alternatives or state when to prefer another tool, so the guidance is largely implicit.

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 annotation readOnlyHint already marks this as safe to read, and the description reinforces that by starting with 'Read'. It adds behavioral context by naming exactly which data domains the read covers, giving the agent a clearer picture of what the call will fetch beyond the bare annotation.

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 entire description is a single front-loaded sentence starting with the key verb 'Read'. It lists the relevant data categories in a compact, scannable way with no filler or redundancy.

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

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

For a simple read-only tool with an output schema and a readOnlyHint annotation, the description is nearly complete. The only meaningful gap is the lack of prose around the parameters, especially tenant_id, but the required audit_project_id is still discoverable from the schema.

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

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

Schema description coverage is 0%, and the description does not explain audit_project_id or tenant_id. The term 'audit_project_id' is somewhat inferable from the tool purpose, but tenant_id is left entirely unexplained, so the description fails to compensate for the lack of schema parameter details.

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 uses the explicit verb 'Read' and identifies a specific resource ('AI Stack Audit project state') plus concrete data categories (deliverable refs, credit ledger, Desk/CRM links). This clearly distinguishes it from sibling tools like artifact_audit or other status 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 implies when to use the tool: whenever an agent needs to read the AI Stack Audit project state or its related data. However, it offers no explicit guidance about alternatives, when not to use it, or how it compares to other status-oriented sibling 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, and the description adds a useful guarantee that it does not expose secrets. However, it does not discuss failure behavior, authorization requirements, or any operational side effects beyond the read-only claim.

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

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

Two short sentences deliver the core purpose and the key confidentiality boundary with zero filler. The essential information is front-loaded, and every phrase earns its place.

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

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

For a simple optional-parameter health check, the description plus annotations, input schema, and output schema cover the operational essentials. A small gap is the lack of explicit guidance on when to prefer this status tool over sibling status tools.

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

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

Schema description coverage is 100%, and the single optional 'role' parameter is already documented in the schema, including its fail-closed behavior on mismatch. The tool description adds no parameter-level meaning, so the baseline of 3 applies.

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

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

The description states a specific action and resource: a read-only health/status check of the StackFast connector. The StackFast connector scope clearly distinguishes it from sibling status tools such as ai_receptionist_status and audit_status, and the confidentiality note adds a meaningful boundary.

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

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

The description implies when to use the tool—when an agent needs StackFast connector health/status—but it does not explicitly state when not to use it or name alternatives. There is no routing guidance beyond the tool's inherent purpose.

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

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

Beyond the annotations, which already mark it read-only and idempotent, the description adds valuable behavioral context: it relies on a human-authenticated server record, cannot substitute model output for human authority, does not bypass Studio, and does not expose credentials. No contradiction with annotations exists.

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 main action is front-loaded and the description is compact overall. There is some redundancy between the second and third sentences, particularly around creating approvals and publishing publicly, but the added security context earns the length.

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

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

For a two-parameter read-only validation tool with an output schema and rich annotations, the description covers the operation, security boundaries, and non-behaviors well. The main gap is the lack of parameter semantics, especially given the empty 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 description coverage is 0%, so the description must compensate for the lack of parameter-level documentation. It provides only 'by id' and never explains the distinction between package_id and approval_receipt_id, leaving the agent to infer semantics solely from the parameter names.

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

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

The description states a specific verb and resource: 'Read and validate a server-recorded, human-authenticated approval receipt by id.' It also distinguishes itself from siblings by explicitly listing what it does not do, such as creating approvals, impersonating Robert, or publishing publicly.

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 makes the intended use clear: validate an existing approval receipt, but not to create approvals or alter release state. It provides boundary conditions and context for when this tool cannot be used, though it does not explicitly name a sibling alternative.

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 says 'Create...', 'append... record', and 'registers... receipts', all implying persistent state changes, while annotations declare readOnlyHint=true. This is a direct contradiction, so the description actively misleads the agent about side effects. The rich caveats about zero cost and no vendor call cannot compensate for this fundamental conflict.

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

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

The opening sentence is front-loaded and dense with purpose, and the later clauses about no vendor call, no human pass, and distinct stages are informative. However, the description is one long block with some redundancy between 'No create path can mint a human pass or make a vendor call' and the later list of what it does not bypass/mint/substitute, so it is not as concise as it could be.

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

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

For a complex tool, the description covers a lot: three modes, zero-cost semantics, authority gates, integration with production.status, and explicit exclusions. But the readOnlyHint contradiction makes the overall context unreliable, and it never explicitly states which sibling should handle the paid canary/full generation/publication stages, leaving an important routing gap.

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

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

Schema description coverage is 67%, and the description does add value by explaining content_type=audiobook_production semantics and referencing a tenant-bound preview reference. However, it does not systematically describe source_hashes, preview_digest, content_fingerprint, or the full input object semantics beyond what the schema already provides; the schema remains the primary source for most 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 opening sentence enumerates three distinct create modes (governed Work Sample, private narration-review contract, zero-cost audiobook preparation) with specific verbs and a resource, and the rest of the description distinguishes this surface from production.status and from paid canary/full generation/publication stages. This is specific enough to tell cogentcast_package_create apart from siblings like cogentcast_production_run and cogentcast_package_preview.

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 clear contexts for using the tool: content_type=audiobook_production registers exact receipts at zero cost, and paid canary, full generation, and publication are stated to be distinct receipt-gated stages, implying those belong elsewhere. It also states what no create path can do. However, it never explicitly names the sibling tool to use for paid canary/full generation/publication, so it stops short of full when-versus-alternative guidance.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description adds substantial non-obvious behavior: failed previews return no creation-authorizing digest or authoritative cost estimate, audiobook production mode operates at zero cost, and the tool does not mint approvals, publish publicly, or expose credentials. This goes well beyond the structured hints.

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

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

The first sentence is a strong front-loaded purpose statement, but the rest of the paragraph becomes dense and tangential, especially the 'Audiobook Production v1 reuses this five-tool surface' and 'production.status returns...' material. Most of that ecosystem context could be condensed or moved elsewhere; the description is not concise relative to the actual invocation task.

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 a rich schema and an output schema, the description together with annotations covers the essential invocation context: mutability, cost, failure response, and approval/publication boundaries. Nothing critical is missing, though the workflow digression slightly obscures the otherwise complete 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 description coverage is 100%, and the schema itself thoroughly documents the nested `input` object and its fields. The description adds mode-specific context for `content_type` values and some failure semantics, but it does not meaningfully clarify the many optional parameters. The schema carries the parameter-semantics burden, so the baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Validate a Work Sample, content_type=narration_review, or content_type=audiobook_production configuration without creating state or vendor cost.' It clearly identifies the supported modes and contrasts with the mutation-oriented sibling tools by emphasizing that this is a preview/validation action, not a creation or production run.

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

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

The first sentence establishes the core usage context: use this tool to validate a configuration before any state or vendor cost is incurred. The negative boundaries — no Studio bypass, no Chief Editor/Robert approval minting, no publication, no credential exposure — tell the agent what this tool cannot be used for. However, it never explicitly names alternatives like cogentcast_package_create or cogentcast_production_run for the actual creation/full-generation steps, so sibling routing is implied rather than fully explicit.

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

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

The description adds many behavioral constraints: receipt binding, provider ambiguity blocking paid retry, no verification minting, no credential exposure. However, it directly contradicts the annotations: it describes requesting a leased, cost-bearing production stage with paid retries, while readOnlyHint=true signals no state modification. This is an annotation contradiction, so the score must be 1.

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 long, dense block of nested caveats and repeated restrictions. It front-loads the core verb well, but the rest is not scannable: key rules about receipts, stages, and limitations are buried in complex prose that would be much clearer as structured bullets.

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 high complexity—10 parameters, 0% schema coverage, and a non-trivial domain—the description is not complete enough. It provides valuable receipt-gating rules and limitations, but omits parameter semantics, stage value options, and consistent side-effect behavior. The readOnlyHint contradiction further undermines an agent's ability to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate for 10 undocumented parameters. It references dispatch/task/job/source receipts and content_type=audiobook_production, but it never explains package_id, idempotency_key, allowed stage values, chunk_id, segment_id, manifest_sha256, verifier_job_id, verification_task_id, or sample_scope. This leaves an agent guessing about most inputs.

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

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

The description opens with a specific verb+resource: 'Request one leased production stage.' It then distinguishes stage families (Gemini reconciliation vs canary/full-chunk) and explicitly separates this from status, approval, and publication actions, so an agent can tell it apart from siblings like cogentcast_production_status and cogentcast_approval_resolve.

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 when-to-use conditions: the zero-cost Gemini reconciliation stage requires exact dispatch/task/job/source/Chief Editor receipt binding, while paid canary/full-chunk stages require prior Chief Editor, Gemini, and human receipts. It also states exclusions—cannot record human approval or publish—and points to production.status for gate status, which is strong routing guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the bar is lower, and the description adds meaningful context beyond that: private source bodies and blob locations are not exposed, paid canary/full generation/publication are distinct receipt-gated stages, and the tool uses the existing CogentCast service without minting approvals or publishing. 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 main purpose is front-loaded, but the description is overlong for a one-parameter read-only status tool. The aside about 'Audiobook Production v1 reuses this five-tool surface: content_type=audiobook_production registers exact manuscript/script/SSML...' is extraneous for this specific tool and makes the description harder to parse quickly.

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

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

Despite verbosity, it is complete for an agent to select and invoke the tool: it names the resource scope, the gate types returned, limitations on what is exposed, and the parameter schema fully documents package_id. With an output schema present, no return-format explanation is needed.

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

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

Schema description coverage is 100%, with package_id already described as a 'ws_, ccnr_, or ccaud_ package identifier.' The tool description does not add any new semantic detail about the parameter that the schema does not already provide, so the baseline of 3 is appropriate.

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

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

The description opens with a specific verb and scope: 'Read tenant-scoped Work Sample, narration-review, or audiobook-production state; exact hashes; current-vs-historical derivative projection; and Chief Editor/Gemini/ear/paid/publication gates.' This clearly identifies the resource and what the tool reports, distinguishing it from the creation/run/approval sibling 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 conveys clear context: this is the read-only status surface for CogentCast production, returning derivative and gate state. It also states exclusions such as 'it does not bypass Studio, mint Chief Editor/Robert approval... publish publicly, or expose credentials,' which helps an agent know when not to misuse it as a shortcut. However, it does not explicitly name alternative tools or say 'use production_run when you need to generate.'

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

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

Beyond the readOnlyHint annotation, the description adds meaningful behavioral guarantees: it never returns raw credentials and only returns non-sensitive metadata such as slugs, aliases, categories, and resolver guidance. It also communicates the 'wallet-resolved' nature of the lookup, giving an agent a clear safety and output model.

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 three focused sentences: what the tool does and its safety guarantee, when to use it, and what it returns. It is front-loaded with the most important distinction and contains no filler or redundant restatement of the title or schema.

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 only one optional, fully documented parameter, a readOnlyHint annotation, and an output schema, the description covers all necessary context. It explains the tool's purpose, triggering scenarios, output contents, and safety boundary, so an agent has enough information to invoke it correctly.

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

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

The input schema already provides full descriptions of the single optional query parameter, including examples and natural-language support, so schema description coverage is 100%. The tool description adds use-case context but does not add additional parameter-level semantics beyond what the schema already states.

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

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

The description uses a specific verb and resource: it 'discovers wallet-resolved credential service names and accepted aliases' while explicitly stating it does not expose secret values. It also names concrete use cases and clarifies that it returns only metadata like service slugs, aliases, categories, and resolver guidance, which clearly distinguishes it from a credential-fetching tool.

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

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

The description gives explicit contexts for use: when an agent is unsure whether a key exists, encounters a key-not-found error, or needs the canonical getAgentKey(service) name. It does not describe when not to use the tool or name alternatives, but the guidance is specific enough for an agent to select this tool correctly.

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, and the description consistently reinforces this with the explicit 'never writes CRM or inventory, never replaces human authority' list, which adds meaningful context about side-effect boundaries. It also discloses behavioral traits beyond the annotations: the return shape ('eligibility or hold decision, a human action card, and an opaque receipt') and the restricted operator-only nature of two modes. No contradiction exists between description and 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?

Three dense sentences with zero filler: the core function is front-loaded, followed by the return contract, then the safety boundary and mode entitlements. Every clause earns its place — the exclusion list is high-value disambiguation, not padding. The length is proportionate to 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?

For a highly complex tool (6 params, deep nesting, output schema present), the description covers the essential ground: the evaluated rule set, the decision output, the audience restriction on modes, and a clear non-mutating boundary. The main gap is that it doesn't explicitly map each mode to its expected payload (evaluate→evaluation, record_stop→stop, register_governance→governance), though the schema's required fields and mode names largely carry that inference. Return values are covered partly by the description and partly by the existing output schema, so no deduction is needed there.

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 prose carries the burden for parameter meaning. The description partially compensates by decoding the critical required parameter, mode, explaining which modes customers are entitled to (evaluate, synthetic_acceptance) versus operator-only ones (register_governance, record_stop). However, the other five parameters (evaluation, stop, governance, tenant_id, fixture_id) receive no prose explanation, leaving the agent to infer mode-to-payload mappings from the schema alone.

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

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

The description names a specific verb ('checks'), a scoped resource ('a tenant-scoped lead'), and a concrete rule set (consent, STOP, quiet-hours, pacing, verified-sender, identity, assignment, manager-exception). The negative clause ('It never sends outreach...') sharply distinguishes it from send/action siblings, and the title reinforces the purpose. An agent can identify exactly what this tool does without opening the schema.

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

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

The description gives clear context for when to use the tool (evaluating a lead against compliance rules before follow-up) and explicit non-goals ('never sends outreach, clears STOP, writes CRM or inventory, reserves inventory, calculates a deal...'). It also partitions modes by audience ('entitled customer modes are evaluate and synthetic_acceptance; governance registration and STOP recording are operator-only'). It stops short of naming specific sibling substitutes for the excluded actions, so it earns a 4 rather than a 5.

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

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

Beyond the readOnly/idempotent/destructive annotations, the description discloses the governed T0 rail, the specific output components (findings, plan, next actions, citations, human action card, opaque receipt), and a detailed list of non-actions (no outreach, no CRM/inventory writes, no authority changes, no assessment, no credential grants). This is rich contextual behavior that is not derivable from the annotations.

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

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

The description is three sentences: purpose first, then machinery/outputs, then exclusions. No fluff, but it is dense with jargon ('governed T0 public judgment rail', 'opaque receipt') that may require unpacking. Still, every sentence earns its place.

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

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

Annotations cover safety and idempotency, and an output schema exists so return values need not be enumerated. The description covers scope, behavior, and non-actions, but lacks explicit usage guidance versus alternatives and leaves several option parameters (mode, role_context, fixture_id) undocmented. For a 9-param workflow selector, this is a meaningful gap.

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

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

Schema description coverage is low (33%, only situation, tenant_id, opportunity_ref have descriptions). The description adds meaning only for the workflow enum by restating its values in prose, but leaves mode (including synthetic_acceptance), role_context, fixture_id, schema_version, and idempotency_key unexplained. It does not compensate effectively for the low schema coverage.

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

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

States a specific verb and resource: 'returns a ... coaching brief' for six explicitly enumerated workflows. The scope is clearly bounded by 'public-safe, tenant-scoped', distinguishing it from siblings like dealership_check_lead_follow_up or estimator 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 clear context by enumerating the exact coaching scenarios (opportunity leak diagnosis, ownership/next actions, daily manager reconciliation, etc.), which tells the agent when this tool applies. It does not explicitly name alternatives or state when not to use it, so it stops short of a 5.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful context about tenant scoping and the estimator_* control-plane contract, but 'Operate on' still leaves the actual behavior ambiguous. No direct contradiction with annotations exists.

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 short sentence but is under-specified rather than efficiently concise. It spends words on generic phrases like 'Operate on' and 'through the generic estimator_* control-plane contract' without delivering actionable purpose or usage 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?

Given the high complexity—13 parameters, nested objects, sparse schema descriptions, and many sibling tools—the description is far from complete. It lacks a clear operation, invocation criteria, and parameter semantics, so even the presence of an output schema and annotations cannot make this definition sufficient for reliable use.

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 15%, with most of the 13 parameters undocumented in the schema. The description does not explain what line, lines, query, bridge, format, approval, source_id, document_id, estimate_id, progress_pct, or idempotency_key mean in this contract, so it fails to compensate for the low coverage.

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

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

The description is vague: 'Operate on tenant-scoped OCE Estimator/Appraiser catalog sources/items' uses a generic verb and never states that this is a search/lookup behavior despite the tool name. It does not distinguish the tool from sibling estimator_catalog_sources, so an agent cannot tell what specific action is being exposed.

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

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

There is no guidance on when to use this tool versus alternatives such as estimator_catalog_sources, estimator_policy_check, or other estimator_* siblings. No use case, exclusions, or preferred invocation context is described, so the agent must guess.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds tenant scoping and the generic control-plane contract context, but it does not disclose additional behavioral traits such as how operations are selected or what side effects might occur.

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

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

The description is a single, front-loaded sentence with no filler. It quickly establishes the scope and resource. The phrase 'generic estimator_* control-plane contract' is jargon, but the overall length is appropriate.

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?

This is a complex tool with 13 optional parameters, additionalProperties allowed, and no required fields, yet the description gives no operation semantics or payload guidance. The output schema and annotations cover returns and safety, but the description is insufficient for an agent to know how to construct a valid request.

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 15%, and the description does not compensate for the 13 undocumented parameters. It mentions 'tenant-scoped' and 'catalog sources/items,' which loosely relate to tenant_id and line/lines, but it provides no meaning for query, bridge, format, source_id, document_id, estimate_id, progress_pct, or idempotency_key.

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

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

The description names the resource (tenant-scoped OCE Estimator/Appraiser catalog sources/items, including StackFast storefront catalog), but the verb 'operate' is generic and does not specify whether this lists, creates, updates, or deletes. It is not a tautology, but it does not give the agent a precise action to expect.

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 domain context but no explicit guidance on when to use this tool versus alternatives. It does not mention estimator_catalog_search or any other sibling, nor does it state conditions or exclusions. Usage is only implied by the resource name.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds only the tenant-scoped boundary and a resource list; it never states what invoking the tool actually does to an estimate or line, leaving the central behavior undisclosed.

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 single sentence is short, but its length comes from an undifferentiated list of resources, not from informative content. It front-loads a vague verb and does not earn its place because none of the listed resources are tied to the add-line action.

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

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

For a tool with 13 parameters, nested objects, an output schema, and many siblings, this description is drastically incomplete: no action, no prerequisites, no parameter guidance, and no selection criteria. The output schema cannot compensate for not knowing when or how to invoke the tool.

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

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

With only 15% schema description coverage and core parameters like line/lines/estimate_id undocumented, the description needed to compensate but remains silent on parameter meaning. 'Tenant-scoped' loosely maps to tenant_id but gives no help for the line object(s), query, bridge, or format fields.

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 uses the generic verb 'Operate' and lists an overly broad set of resources (drafts, lines, versions, documents, exports, policy receipts) without ever stating that this tool adds a line to an estimate. This fails to distinguish it from siblings like estimator_estimate_update_line or estimator_estimate_export. It is only marginally better than a tautology because it names the domain.

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

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

There is no statement of when to call this tool or when not to. The broad wording 'Operate on drafts, lines, versions, documents, exports, and policy receipts' actively implies a much wider scope than add_line, which could mislead selection among the estimator_* siblings.

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

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

Annotations already cover readOnly, idempotent, and non-destructive behavior, so the description is not required to restate those. It adds tenant-scoped context and enumerates the domain objects, which is helpful, but it does not explain what 'convert to bid' actually does or what the output represents.

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 sentence with no filler, so it is concise, but it sacrifices substance. It front-loads a vague verb and a long list of object types without structuring the key action or differentiating context.

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

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

Given 13 parameters, nested objects, an output schema, and many sibling tools, this description is far too thin. It leaves the conversion purpose, parameter relationships, and workflow context unexplained, so an AI agent cannot reliably select or invoke this 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 only 15%, and the description adds essentially no parameter-level meaning. The 'tenant-scoped' phrase aligns with tenant_id, but critical parameters such as line, lines, query, bridge, format, approval, source_id, document_id, estimate_id, progress_pct, and idempotency_key remain unexplained.

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

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

The description uses the generic verb 'Operate on' and lists OCE Estimator/Appraiser objects, but it never states the specific action of converting an estimate to a bid. It also does not distinguish this tool from sibling estimator_estimate_convert_to_invoice; only the tool name carries the conversion intent.

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

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

No guidance is provided on when to use this tool versus alternatives such as estimator_estimate_convert_to_invoice or other estimator tools. There is no mention of prerequisites, input state, or which workflow should select 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?

The description aligns with readOnlyHint and idempotentHint, and adds genuine behavioral context by stating the operation is review-gated and does not write to accounting systems. With annotations already covering the read-only and non-destructive profile, the added context is modest but not redundant.

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 compact sentence with no filler, and the core deliverable is front-loaded. It sacrifices substance for brevity, but as written it is well-structured and easy to parse.

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 13-parameter, zero-required tool with key siblings like convert_to_bid, progress_invoice, and export, this definition leaves too much implicit: source selection, approval flow, format semantics, and adapter-specific behavior are all unaddressed. The output schema and annotations provide some context, but the description alone is not sufficient for correct invocation.

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

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

Schema description coverage is only 15% across 13 parameters, and the description compensates for none of that gap. It gives no hints about how to select the source estimate, which lines or query to use, what approval or progress_pct mean, or how format affects output, leaving an agent with almost no semantic grounding for parameter choices.

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

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

The description names a deliverable ('OCE Estimator/Appraiser document or QBO handoff contract') and a verb ('Prepare'), but it never explicitly says it converts an estimate into an invoice; that is only inferable from the tool name. It also doesn't distinguish itself from the sibling estimator_estimate_convert_to_bid, so the purpose remains somewhat ambiguous.

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

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

No guidance is given on when to use this tool versus estimator_estimate_convert_to_bid or estimator_estimate_progress_invoice. 'Review-gated; does not write to accounting systems' is a constraint, not a usage rule, and no alternatives or conditional selection criteria are mentioned.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description adds no behavioral detail beyond that. 'Operate on' is ambiguous about whether the tool reads or modifies, though it does not explicitly contradict the read-only annotation. No auth, rate-limit, or side-effect context is disclosed.

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

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

The description is short and free of filler, but it is under-specified rather than deliberately concise. 'Operate on' plus a list of resource categories conveys almost no actionable information. The sentence does not earn its place as a useful tool definition.

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

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

For a tool with 13 parameters, nested objects, and no required fields, this description is far too thin. Although output schema and annotations exist, the agent still lacks a statement of the tool's core behavior, when to use it, and how parameters map to the operation. The definition is not sufficient for correct selection or invocation.

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

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

With only 15% schema description coverage, the description needed to explain key parameters like line, lines, query, format, document_id, estimate_id, progress_pct, and idempotency_key, but it mentions none of them. The phrase 'tenant-scoped' only weakly echoes the tenant_id schema description. An agent cannot infer how to construct a valid call from this text.

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 uses the vague verb 'Operate on' and never states the primary action of creating a draft. It lists many resources (drafts, lines, versions, documents, exports, policy receipts) without identifying which one this tool actually acts on, so it cannot be distinguished from sibling tools like estimator_estimate_add_line or estimator_estimate_export. This reads as a namespace description rather than a specific tool purpose.

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

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

No guidance is given on when to use this tool versus its many estimator siblings. The only contextual clue is 'tenant-scoped', which is a scope constraint, not a usage condition. There are no exclusions, preconditions, or alternative tool routing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. However, the description adds only a broad entity list and tenant scoping, not meaningful behavioral context such as what the export generates, whether it returns an existing artifact, or what side effects may occur. 'Operate on' is too generic to be transparent about behavior.

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

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

The description is short, but it is under-specified rather than concise. It front-loads no actionable specifics and uses one generic sentence to cover an entire domain, which forces the agent to guess the actual operation.

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

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

For a tool with 13 parameters, zero required fields, nested objects, and a low-coverage schema, the description is far too incomplete. It does not indicate which parameters are needed for an export, what the inputs mean, or how the operation should be invoked. Even with an output schema present, the agent lacks enough information to correctly assemble a call.

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 15%, with only tenant_id and adapter_id described. The description does not explain any of the 13 parameters, such as format, estimate_id, document_id, query, bridge, approval, or idempotency_key, nor how they relate to the export operation. With such low schema coverage, the description was expected to compensate, but it provides no parameter-level 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 uses the vague verb 'Operate on' and lists a broad collection of resources (drafts, lines, versions, documents, exports, policy receipts) without stating the specific operation. It does not clearly say that this tool exports an estimate, nor does it distinguish itself from siblings like estimator_estimate_create_draft or estimator_estimate_convert_to_invoice.

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

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

There is no guidance about when to use this tool versus alternatives, no exclusions, and no mention of sibling tools or conditions. The phrase 'tenant-scoped' gives a contextual boundary but does not help an agent decide between this export tool and the many other estimator_* 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description correctly reinforces 'does not write to accounting systems' without contradiction. It adds useful context beyond annotations by explaining the workflow is 'review-gated,' which informs the agent about an approval step not otherwise visible in the structured metadata.

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: the first sentence states the main action, and the second adds key behavioral context. The 'or' ambiguity slightly reduces clarity, but the text is well-sized and free of fluff.

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

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

For a tool with 13 parameters, nested objects, and low schema description coverage, the description is far too thin. It does not explain what inputs are needed, what the output document represents, or how the review gate works. While the output schema exists and annotations cover safety, the agent still lacks enough information to invoke this 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 only 15%, with 13 parameters and several nested objects, so the description must compensate by explaining parameter semantics. It does not mention any parameter, input relationship, or how fields like line, lines, query, bridge, approval, or progress_pct should be used. The tooling has essentially no useful parameter 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 says the tool 'Prepare[s] an OCE Estimator/Appraiser document or QBO handoff contract,' which gives a general verb and resource, but the disjunctive 'or' makes the exact deliverable ambiguous. It does not clearly state that this is a progress-invoice estimation tool, nor does it differentiate it from siblings like estimator_estimate_convert_to_invoice or estimator_estimate_export.

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

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

No guidance is provided about when to use this tool versus sibling tools. The description mentions it is review-gated and non-writing, but there is no indication of which scenario requires this tool rather than estimator_estimate_convert_to_invoice, estimator_estimate_export, or estimator_estimate_create_draft.

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 annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, but the description adds only a generic 'tenant-scoped' boundary and a broad resource list. It does not explain what happens when the tool is called, what fields are affected, or why the operation is read-only despite the 'update_line' name.

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

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

The description is short, but its single sentence is an unfocused list of resource types rather than a purposeful summary. It does not front-load the key action or make efficient use of the sentence to convey what this specific tool does.

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?

This is a complex tool with 13 optional parameters and nested object inputs, yet the description gives almost no operational context. The output schema may cover return values, but the agent is left without any understanding of how to construct a valid call or what the tool is actually for.

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 only 15% schema description coverage and 13 mostly undocumented parameters, the description needed to provide substantial parameter context. It provides none, leaving line, lines, query, bridge, format, approval, source_id, document_id, estimate_id, progress_pct, and idempotency_key with almost no meaning beyond their names.

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

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

The description uses the vague verb phrase 'Operate on' and lists a broad set of resources (drafts, lines, versions, documents, exports, policy receipts) without stating that this tool specifically updates an estimate line. It fails to convey the tool's core action and does not distinguish it from the many sibling estimator 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?

There is no guidance about when to use this tool, what conditions are appropriate, or when to prefer a sibling like estimator_estimate_add_line. The description provides no decision-making context, leaving the agent to infer usage from the tool name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. However, the description adds no behavioral detail beyond 'tenant-scoped' and a resource list; 'Operate on' is ambiguous and does not clarify whether this performs a read-only policy validation or some other action.

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 short and front-loaded, but brevity is not useful when it omits the core action. This is under-specification rather than efficient conciseness, so the sentence does not earn its place.

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

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

Given 13 loosely-typed parameters, zero required parameters, additionalProperties=true, and many sibling estimator tools, the description is far too incomplete. Even with an output schema present, an agent cannot determine what inputs to provide or what operation is being performed.

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 13 parameters and only 15% schema description coverage, the description needed to explain key parameters, but it explains none. It only hints at tenant scoping, which maps to tenant_id. The many objects and strings (line, lines, query, bridge, format, approval, source_id, document_id, estimate_id, progress_pct, idempotency_key) are left entirely undefined.

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 uses the generic verb 'Operate on' and lists resource types (drafts, lines, versions, documents, exports, policy receipts) without stating what the tool actually does. The title says 'policy check', but the description never says it checks or validates policy. It is too vague to distinguish from sibling estimator_* 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?

No when-to-use guidance, no exclusions, and no mention of alternatives. The description does not explain when an agent should choose this tool over estimator_estimate_export, estimator_receipt_get, or other estimator_* siblings. The only clue is the title, which is insufficient.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, but the description adds no behavioral detail such as what data is returned, whether filtering is applied, or what 'receipt' means in this context. The broad phrase 'Operate on ... drafts, lines, versions, documents, exports, and policy receipts' is vague and could suggest more than a read-only get operation, though it does not directly contradict the annotations.

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

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

The description is short, but brevity is not the issue; it is under-specified. One generic sentence that lists eight entity types does not provide a useful structure or front-loaded operational meaning. This is closer to an empty placeholder than a deliberately concise definition.

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

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

Given 13 parameters, no required fields, nested objects, an output schema, and a broad set of sibling tools, the description is severely incomplete. It does not clarify the core operation, which parameters are central, what the output represents, or how this tool fits the estimator workflow. An agent cannot confidently invoke this 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 only 15%, and the description contributes zero additional parameter meaning. With 13 parameters, many being opaque nested objects like 'line', 'lines', 'bridge', and 'approval', the description must compensate for the schema gap but does not.

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

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

The description says 'Operate on' with a long list of entities, but this is not a specific verb+resource statement. The tool name suggests a receipt getter, yet the description never explicitly says what it retrieves or produces. It also does not distinguish this tool from sibling estimator tools like estimator_estimate_export or estimator_catalog_search.

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

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

There is no guidance on when to use this tool versus alternatives. It does not state the intended scenario, preconditions, or whether it is preferred over estimator_policy_check, estimator_estimate_export, or other estimator tools. An agent is given no decision-relevant information.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful behavior beyond annotations by explaining the paged fetch loop with next_page and complete, and by characterizing artifacts as immutable and authorized.

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

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

Two sentences front-load the core purpose, immediately give a safe usage template, and close with the pagination termination condition. There is no filler; every phrase earns its place.

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

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

The description is complete enough for a read-only paged fetch tool: id format, required parameters, page size bounds, pagination continuation, and termination condition are all covered. An output schema exists, so the return shape does not need to be restated in prose.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds concrete examples of the expected id format ('brain:12345', 'artifact:474'), a suggested page_size of 12000, and clarifies the pagination flow. This goes beyond the schema descriptions by showing a complete valid invocation.

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 specifies a concrete action—'Fetch a StackFast Brain result or an authorized immutable session artifact by id'—and names the resource type and access plane. It is distinct from sibling search tools because it is explicitly id-based, though it never names an alternative sibling.

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

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

The description gives clear operational guidance: use the explicit id, page, and page_size shape, and continue following next_page until complete is true. It does not state when to choose this tool over search or other siblings, but the id-based usage context is clearly implied.

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

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

The description directly contradicts the annotations: readOnlyHint is true, yet "start or append" implies modifying interview/session state. This is an annotation contradiction. The added note about draft_review_required is useful but cannot compensate for the conflicting state-change semantics.

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

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

The description is a single front-loaded sentence that immediately states the action and resource. It is concise and contains no filler or redundancy.

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 multi-action tool with 11 parameters and contradictory annotations, a one-sentence description is insufficient. It omits parameter semantics, when to use the tool, and fails to clarify behavior beyond the draft_review_required note. The presence of an output schema mitigates but does not eliminate these gaps.

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

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

With 11 parameters and 0% schema description coverage, the description needed to compensate but only provides weak semantic hints like "interview/session model" and "start or append," which loosely map to session_id and the action enum. Most parameters, including answers, company, lead_id, and tenant_id, remain unexplained.

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

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

Description clearly states a specific verb and resource: "Start or append a GrowthOS Business Brain Interview." It does not explicitly differentiate from siblings, but the name and action verbs make the purpose unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives such as growthos_scorecard or other interview-related tools. The description does not state prerequisites, exclusions, or selection conditions.

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 read-only, idempotent, and non-destructive behavior. The description adds meaningful guardrail context beyond those hints: output is explicitly a draft, no Robert voice defaults are applied, and autonomous outbound is forbidden. These are the kinds of behavioral details an agent needs and do not repeat the annotations.

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

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

The description is two concise sentences with the primary action front-loaded and the safety constraints packaged into the second sentence. Every clause earns its place and there is no redundant restatement of the title or schema.

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 strong output schema, full parameter descriptions, and annotations covering safety and idempotency, the tool description covers the purpose, core inputs, and critical non-behaviors. Nothing essential to invoking the tool correctly is missing, and the schema handles the remaining return/delivery details.

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

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

Schema description coverage is 100%, so the structured schema already documents all three parameters. The description adds light semantic framing by connecting prospect evidence, tenant voice profile, and PERSPECTIVE grounding to the processing pipeline, but it supplies no operational parameter detail beyond what the schema already provides.

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

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

The description names a concrete action ('Build a draft GrowthOS digital-clone render packet') and a specific resource, and the closing constraint ('No Robert voice defaults and no autonomous outbound') clearly separates it from any publishing or outbound sibling. It leaves no doubt that the tool produces a draft rather than taking external action.

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 intended use is implied: build a digital-clone draft from prospect, tenant profile, and perspective grounding. However, the description does not explicitly state when to choose this tool over sibling packet tools like growthos_opportunity_scout_packet or growthos_revenue_capture_packet, nor does it list exclusions or alternative conditions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds meaningful behavioral context beyond those: it states the operation uses the 'existing gate-first policy layer' and creates 'no new persistence table,' which clarifies that this is a non-persistent, policy-governed packet build. 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?

One sentence that front-loads the action and resource, immediately lists scope categories, and appends constraints ('gate-first policy layer' and 'no new persistence table'). There is no redundant or filler content.

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

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

Given the simple one-parameter schema, the rich annotations, and the presence of an output schema, the description is complete. It covers what is being built, for which opportunity types, and the key behavioral constraints, leaving no critical invocation 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?

Schema coverage is 100% for the single parameter, so the baseline is 3. The description adds value by listing potential opportunity categories (customer, talent, contract, capital), giving the agent hints about what the nested 'opportunity_type' field might contain beyond the schema's generic 'registered Opportunity Scout types' phrasing.

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

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

The description states a specific verb ('Build'), a specific resource ('Opportunity Scout packet'), and enumerates the covered opportunity categories (customer, talent, contract, or capital). This clearly communicates the tool's function and distinguishes it from vague or generic packet tools in the sibling list.

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

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

The description gives clear context for when to use the tool: when an Opportunity Scout packet is needed for one of the named opportunity categories. It does not explicitly name alternatives or exclusions, but the scope is specific enough that an agent can infer appropriate 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, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds a critical behavioral boundary—'No autonomous send'—and clarifies the nature of outputs without contradicting the annotations.

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

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

The description is two tight sentences with no filler. The core purpose and output formats are front-loaded, followed by the important 'No autonomous send' constraint and the optional integration in a compact, readable way.

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 that an output schema exists and annotations cover the operation's safety, the description provides the essential context: rendering the scorecard, available output formats, and optional CogentCast behavior. A slight gap is that the required prospect object and the 'step 3' reference in the schema are not explained, but the overall invocation intent is clear.

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%; the two CogentCast-related parameters have helpful descriptions in the schema, and the tool description reinforces their purpose. However, the sender and prospect object parameters are undocumented in both the schema and the description, leaving their expected structure to be inferred from the tool name and context.

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

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

The description states a specific verb ('Render'), a clear resource ('canonical GrowthOS scorecard'), and a distinct deliverable ('sendable owner-facing report') with concrete output formats (web, email-review-ready, PDF-ready). It also names the optional CogentCast receipt composition, which clearly differentiates it from sibling tools like growthos_scorecard or cogentcast_production_run.

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 clearly implies when to use the tool: when a GrowthOS scorecard needs to be turned into an owner-facing, sendable report. It does not explicitly name alternatives or exclusions, but the context is strong enough that an agent can infer this tool is for rendering/reporting rather than sending or producing the underlying scorecard.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds meaningful context beyond those annotations: GrowthOS consumes CogentCast receipts rather than recreating website-review logic, and 'No autonomous outbound' clarifies that the tool produces drafts/packets without sending them. There is no contradiction with the annotations.

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

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

Three sentences with no filler: the first front-loads the deliverable and its components, the second adds the key integration behavior, and the third states a crucial constraint. Every sentence earns its place.

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

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

For a 4-parameter packet tool, the description covers the deliverable components, the CogentCast integration, and the no-outbound constraint, with output schema and annotations covering return values and safety. Yet it does not explain the required `prospect`/`sender` shapes and gives no explicit guidance for choosing among the many sibling packet tools, so the description is not fully complete for an autonomous agent.

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 descriptions cover the two CogentCast-related parameters, and the main description loosely ties `prospect` to 'supplied local-business evidence.' However, `sender` and `prospect` are nested objects with no property-level schema descriptions, and the description does not meaningfully explain what should go into them, leaving a real gap at 50% coverage.

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

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

The description uses a specific verb ('Return') and a specific resource ('GrowthOS revenue-capture packet'), then enumerates the packet's components: scorecard, review-gated contact drafts, CogentCast site-review receipt composition, and summary. This clearly distinguishes it from sibling packet generators even without naming them directly.

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

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

The description gives useful context: the tool is for 'supplied local-business evidence' and explicitly states 'No autonomous outbound,' which tells the agent the packet is not to be sent. However, it never names sibling alternatives or states when to prefer this packet over growthos_digital_clone_packet or growthos_opportunity_scout_packet.

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

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

Beyond the readOnly/idempotent annotations, the description adds meaningful behavioral context: the output is a private scorecard, it returns findings only, it never sends outreach, and it requires reader entitlement. This clearly communicates side-effect boundaries and authorization needs that annotations alone do not fully convey.

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

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

The description is three tight sentences with the core action front-loaded and every sentence earning its place. It covers what it builds, what access is required, and what it never does, without redundancy or filler.

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

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

For a read-only scorecard tool, the description covers purpose, input source, authorization, output scope, and key side-effect boundaries. Since an output schema exists, return details are externally handled; the main gap is not addressing how to select between the optional prospect and prospects parameters or sibling routing.

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

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

Input schema coverage is 100%, with descriptions for sender, prospect, and prospects including a batch limit of 25. The tool description adds little parameter-specific meaning beyond the general notion of 'public business signals,' so it stays at the baseline for well-schematized 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 states a specific verb ('Build') and clearly identifies the resource ('GrowthOS Revenue Capture Scorecard') and input source ('supplied public business signals'). It does not explicitly distinguish this tool from sibling GrowthOS tools like growthos_revenue_capture_packet or growthos_opportunity_scout_packet, which keeps it short of a 5.

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

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

The description provides useful context such as 'MCP execution requires reader entitlement' and 'it never sends outreach,' but it does not explicitly state when to choose this tool over related alternatives or when not to use it. Usage context is present but largely implied rather than directed.

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?

ReadOnlyHint already covers safety, and the description adds meaningful non-obvious behavior: it produces a decision packet with do_not_say/safe_phrasing, requires manual approval, includes an artifact audit trail, and never sends. These traits go beyond a generic read-only flag and do not contradict the annotation.

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

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

Two sentences with no filler: the first sentence front-loads the primary purpose and key packet components, and the second states the crucial 'never sends' behavior. Every word earns its place.

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

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

For a 14-parameter tool with nested objects, no schema descriptions, and no usage routing, the description is too thin. It explains the output concept well but leaves the required channel and major optional parameters unexplained; the presence of an output schema lowers the return-format burden, not the input-semantics burden.

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% for 14 parameters, and the description does not explain the meaning of any input field. The phrase 'channel constraints' hints at channel/constraints but not enough to guide an agent on required channel, crm_context, inbound_message, persist_artifact, or idempotency_key.

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

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

The description names a specific action ('Compose') and a specific resource ('relationship-safe correspondence decision packet'), and enumerates what the packet contains (do_not_say, safe_phrasing, channel constraints, manual approval, artifact audit trail). It is clear, but it does not explicitly differentiate from the many other compose/draft tools in the sibling list.

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

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

'It never sends the message' gives a useful boundary that this is a drafting/decision-stage tool, so usage is somewhat implied. However, the description gives no explicit when-to-use guidance and does not point to alternatives such as talent_scout_draft_outreach or a send tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds that the search operates through the AI6 MCP reader plane and that results return ids for fetch, which is useful behavioral context beyond the annotations.

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

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

The entire description is a single efficient sentence with no filler. It is front-loaded with the action and resource, and the fetch follow-up instruction earns its place.

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

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

For a one-parameter search tool with an output schema and read-only annotations, the description provides the essential workflow: search, get result ids, then fetch full text. It does not mention limits or failure modes, but the presence of an output schema and the simple scope make this adequate.

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

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

Schema description coverage is 100% and the schema already documents 'query' as a natural language search string. The description adds no additional query-formatting or semantics, so the baseline of 3 applies.

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

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

The description names a specific verb ('Search') and resource ('StackFast Brain knowledge'), and clarifies the read-only plane it operates on. It also distinguishes itself from fetch by telling the agent to use fetch with the returned result id for full 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?

The description clearly says to use fetch with a returned result id for full text, giving an explicit follow-up action and signal that search results are summaries/ids. It does not enumerate when not to use search versus the many other search-like siblings, but the specific resource scoping makes the intended use unambiguous.

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

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

Annotations declare readOnlyHint=true, and the description adds meaningful behavioral context by noting the V1 limitation and the persistent-URL behavior. This goes beyond the annotation without contradicting it.

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

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

Two short sentences with no filler. The primary purpose is front-loaded, and the intentional omission is stated concisely in the second sentence.

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

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

The description is adequate for a straightforward read-only metadata tool, and an output schema exists to describe return values. However, with no required parameters and no guidance on how to choose among filters, an agent may be uncertain how to construct an effective request.

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 should compensate for the four parameters. However, it does not explain how session_id, artifact_id, filename, or limit are used, nor their relationships. The parameter names are self-explanatory to some degree, but the description adds no parameter-level 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 clearly identifies the verb ('Return') and resource ('session artifact metadata and persistent URLs'), making the tool's purpose specific and unambiguous. It also distinguishes itself from content-returning tools by explicitly stating that raw artifact contents are intentionally omitted.

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 clear context: use this tool when you need artifact metadata and persistent URLs, not raw contents. The 'V1 intentionally omits raw artifact contents' line serves as an implicit when-not, though it does not name alternative tools for fetching raw contents.

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 mark this as readOnly, idempotent, and non-destructive, and the description adds meaningful behavioral context by calling it a draft-only application packet and explicitly stating no sends or applications. This tells an agent exactly what side effects are avoided.

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 front-loaded, but it is one long comma-delimited list. The list is informative for a complex tool and each item largely earns its place, though grouping or bullet formatting would improve scannability.

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

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

For a complex tool with an output scheema and rich annotations, the description covers the full scope of the workup and clearly limits side effects. Minor gaps remain around unexplained terms like 'Robert proof-point map' and how to select between lookup parameters, but the core behavior and expected outputs are complete enough.

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% and the schema already documents aliases and fallback behavior for the lookup parameters. The description adds no parameter-level guidance and instead focuses on outputs, which is acceptable but not compensating beyond the schema's existing coverage.

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

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

The description opens with a specific verb and resource: Build the detailed workup for one Talent Scout queue item. It then enumerates concrete deliverables, making the tool's purpose unmistakable and distinct from sibling send/action tools by stating Draft/review only; no sends or applications.

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 clearly identifies the target context: one Talent Scout queue item, and the boundary: draft/review only with no sends or applications. However, it does not explicitly name an alternative tool for the send path or exclusions beyond that, so it stops short of fully explicit routing.

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

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

Annotations already mark the tool as read-only, idempotent, and non-destructive; the description adds meaningful nuance by disclosing that it maps only safe profile values, reserves eligibility/EEO/files/signature/submit for the human, and requires per-field readback before reporting staged. This aligns with the annotations and gives the agent a clear safety model.

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

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

Two dense sentences with no filler. The primary purpose is front-loaded, and the second sentence efficiently adds the safety boundaries and verification requirement.

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