Klarefi

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

Annotations mark this as destructive and not read-only, but the description adds no behavioral context about side effects, permanence, or required authentication. It only provides value format constraints, which are more relevant to parameter 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 two sentences, directly states the purpose and key formatting rules, with no filler or redundant 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?

The description lacks guidance on authentication flow (url vs access_token+session_id) and doesn't explain task_id/session_id, which is significant given the tool's 6 parameters and no output schema. It is minimal and leaves important operational details for the agent to infer.

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

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

The description adds format guidance for yes_no and date fields beyond the schema, clarifying acceptable values for the fields object. However, it doesn't explain the purpose or usage of task_id/session_id parameters, which are undocumented in the schema.

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

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

The description clearly states the tool's function: answering structured requested facts keyed by fact_id. It uses a specific verb and resource, but doesn't distinguish itself from the sibling tool answer_question, so it lacks sibling differentiation.

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 the tool is for responding to structured fact requests, but it doesn't explicitly say when to use it over answer_question or other intake tools. No exclusions or alternative recommendations are provided.

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

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

Discloses a consequential effect beyond the annotations: the question is closed and not re-asked unless something new arrives, which is exactly the kind of permanence an agent needs to know given destructiveHint=true. It does not address the auth/url requirements or what is returned, leaving minor gaps.

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

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

Two sentences, zero filler, with the primary action front-loaded and the closure consequence immediately after. Every clause carries information.

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

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

For a non-idempotent, destructive write with no output schema, the description covers the action, the optional scoping, and the irreversible closing behavior. It falls short only on the transport/auth parameters and any return indication, which the schema partially covers.

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

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

Schema coverage is 50%; url, access_token, and api_base_url are already documented in the schema. The description adds meaning for the two undescribed core parameters, clarifying that text is free-form and task_id is an optional target, but leaves session_id unexplained. Baseline 3 applies.

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

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

States a specific verb and resource ('Answer the active applicant question with free text') and flags the optional task_id target. The 'free text' framing implicitly distinguishes it from the structured sibling answer_fields, but no sibling is named explicitly.

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

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

Provides real conditional guidance for the failure case ('when the applicant cannot supply what it asks for now, say so and why'), but says nothing about when to choose this tool over answer_fields, submit_intake, or save_intake_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 description adds meaningful behavior beyond the annotations: the result reports whether the configuration is active or staged for operator approval, and checks remain open until connected. The annotations already declare the tool as destructive and non-idempotent, so the description does not need to repeat those safety facts. However, it could do more to clarify destructive effects.

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

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

The description is front-loaded with the core create-or-update action and is composed of four compact, relevant sentences. Each sentence contributes operational information, with no obvious filler. It is slightly dense but well structured.

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 no output schema, the description explains the key result states: active versus staged for operator approval. It also clarifies the staged credential flow and the open-checks condition. It leaves some gaps around destructive behavior and idempotency, which are partially covered by annotations.

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 reported as 100%, so the schema already carries the primary parameter documentation burden. The description adds useful semantics for connection_status and credentials, but does not explain the required fields connector_key, label, connector_type, transport, or functions. This is adequate given high schema coverage, but not a strong supplement.

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: 'Create or update a Klarefi verification connector manifest.' This clearly identifies the operation and domain. It does not distinguish itself from the close sibling create_connector_from_openapi, so it falls short of full sibling differentiation.

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 concrete usage instructions: set connection_status to not_connected and omit credentials to add now, then upsert with connected and credentials later. It also explains that checks remain open until connected. It lacks explicit guidance on when to use this versus create_connector_from_openapi or delete_connector.

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 cover the safety profile (destructive=true, openWorld=true, not idempotent), so the description doesn't need to repeat it. What the description does add is valuable: the result may leave the configuration 'active' or 'staged for operator approval', so the agent learns that this call may not take effect immediately and may need human approval. It also warns about the ordering of credentials. It does not say which permissions are required or how the destructive behavior manifests, so it is one step short of a 5.

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

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

Four short sentences, front-loaded with the core action, and each one adds a distinct fact (format rule, result semantics, status option). There is no filler, though the status hint could be folded into the earlier sentence for better flow.

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

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

Because there is no output schema, the description must explain the return value, and it does so partially by mentioning the active-versus-staged outcome. However, for a destructive, open-world import with 0% schema coverage on five parameters, critical facts are missing: the meaning of connector_key and label, the purpose of base_url, and any hint about what the connector_key must be unique against.

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

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

With schema coverage at 0% for 5 parameters, the description must carry the weight. It explains openapi_url (a public JSON URL, not YAML) and connection_status (the not_connected option for importing before credentials exist), which is genuinely useful. It says nothing about connector_key, label, or base_url, leaving the two required parameters and one optional field undocumented in both the schema and the prose.

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

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

The description states a specific verb and resource: import a public OpenAPI JSON URL as a connector. It defines the input format (JSON only, YAML must be converted), which sharpens the scope. It never distinguishes itself from the sibling create_connector, so the agent can't tell which is the right entry point from the description alone.

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

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

There are clear constraints: the spec must be a public URL and JSON, not YAML, and connection_status=not_connected is the option for importing before credentials exist. However, there is no explicit statement about when to choose this tool over the sibling create_connector, or about preconditions or side effects. The guidance is implied by the constraints rather than stated as a rule for when to use the tool.

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

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

The description simply restates the tool's name and offers no additional behavioral disclosure. It does not mention side effects like persisting a session, generating a URL, or requiring specific permissions, and the annotations (all false) provide no useful signal. With no annotation support, the description carries full burden but fails to add value.

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

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

The description is a single concise sentence with no fluff, but its brevity undermines usefulness. For an 8-parameter tool with no output schema, one sentence is under-specification rather than appropriate conciseness.

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

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

The description provides almost no context for a complex tool. It does not explain what a 'hosted' session entails, what the return value is, how to construct the prefill object, or any constraints around the parameters. Combined with missing output schema and sparse schema descriptions, the tool is far from adequately specified.

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

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

The description is silent on all eight parameters, and the schema's own description coverage is only 13% (just prefill). The required case_type_id and key options like ttl_hours, return_url, and external IDs are left completely unexplained, leaving the agent to guess their meaning and constraints.

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

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

The description identifies a specific action (create) and a resource (a hosted Klarefi intake session), but it does not explain what that session actually is or how it differs from related tools like open_intake or submit_intake. The phrase 'Klarefi intake session' is jargon without context, leaving the purpose somewhat vague.

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 siblings, nor are any prerequisites or preconditions mentioned. An agent is left without context on whether this is the right tool for starting a new intake flow or whether other tools such as save_intake_draft or submit_intake are more appropriate.

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 establish destructiveHint=true, while the description adds useful context by mentioning that deletion may be staged for operator approval. This goes beyond the annotations, but it leaves ambiguous what triggers staging and what the outcome of the call will be.

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 redundant phrasing. It front-loads the primary action and then adds the important staging nuance, making it easy to scan 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?

For a one-parameter destructive tool, the description gives the essential action but not enough detail about the staging behavior, the meaning of connector_key, or what the caller should expect after invocation. The destructive annotation covers the safety profile, but operational expectations remain unclear.

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

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

With 0% schema description coverage, the description must clarify connector_key. It does partially by saying the operation happens 'by key', indicating that connector_key selects the connector. However, it does not explain what a key is, where to find it, or its expected format.

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 ('Delete') with a specific resource ('configured Klarefi connector') and a clear lookup method ('by key'). It also distinguishes itself from the sibling create_connector tools simply by naming the deletion 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: call this when you want to remove a configured connector. However, it does not explain when direct deletion applies versus when deletion is staged for operator approval, nor does it mention any prerequisites or exclusions.

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

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

Annotations already declare read-only and idempotent behavior. The description adds that the tool retrieves 'resolved facts,' which gives some indication of the return payload but doesn't elaborate on formatting, pagination, or any side effects. It provides minimal additional behavioral context beyond annotations.

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

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

The description is a single concise sentence that directly states the action and resource, with no extraneous 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?

The tool is simple with one parameter and no output schema, so the description is relatively complete for basic use. However, the term 'resolved facts' is undefined, and there is no mention of what the response contains or any edge cases, leaving some ambiguity.

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

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

The sole parameter case_id is required, but the schema has no description. The description mentions retrieving a case but doesn't directly explain the case_id parameter or its format. Given the low schema coverage, the description does little to compensate, offering only implicit identification.

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 'Retrieve' and identifies the resource as 'a Klarefi case and resolved facts.' This clarifies the tool's function and distinguishes it from sibling tools like get_case_package and get_case_workspace, though it doesn't explicitly contrast 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?

There is no information about when to use this tool versus alternatives such as get_case_package or get_case_workspace. No exclusions or preferred scenarios are provided, leaving the agent without guidance on tool selection.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds useful behavioral context beyond that: the response is a signed, read-only URL and the package's contents (facts, calculated facts, offer/decline with files), which is genuinely informative about the artifact.

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

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

Two tight sentences, front-loaded with the primary artifact and then its contents. Slightly telegraphic in the second sentence but 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?

With no output schema, the description carries the burden of describing the return and does so (facts, calculated facts, offer/decline, files). For a single-parameter read tool that is adequate, though it omits any note on failure modes or case_id semantics.

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

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

Schema description coverage is 0% for the single case_id parameter, and the description only alludes to it as 'the cited' package without explaining format, scope, or how it maps to the case. It does not compensate for the undocumented parameter.

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

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

States a specific verb and resource ('Get the cited case_package.v1 artifact') plus secondary output ('a signed read-only case-file URL'). It is clear what the tool retrieves, but it never distinguishes itself from close siblings like get_case or get_case_workspace, leaving the agent to infer the difference.

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

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

There is no explicit when-to-use, when-not-to-use, or alternative routing. The phrase 'the cited case_package.v1' hints that a citation context is required, but no prerequisite or sibling comparison is given to help the agent select this over get_case.

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's statement 'This does not mutate the case' is redundant. The description adds context about the returned content but no additional behavioral traits (e.g., rate limits, auth requirements) beyond what annotations provide.

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

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

The description is a single sentence that is concise, front-loaded with the action, and provides specific content details without extra fluff. Every word contributes to understanding the tool's purpose.

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 one parameter and strong annotations, the description lists the key components of the workspace, which serves as an implicit return-value preview. It does not mention edge cases or pagination, but the tool's scope and safety profile are 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?

The schema has one parameter (case_id) with 0% description coverage. The tool description does not explicitly explain the parameter, but the name 'case_id' combined with 'Inspect a case workspace' makes its purpose inferable. This indirect clarification is enough for a baseline, but the description does not add meaningful detail 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 ('Inspect') and resource ('case workspace'), and enumerates the components (facts, cited evidence, blockers, ownership, timeline). This clearly distinguishes it from sibling tools like get_case or get_case_package by focusing on the workspace's internal contents.

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 when a user needs to inspect the case workspace, but it does not explicitly state when to prefer this tool over alternatives such as get_case or get_case_package. No when-not or alternative guidance is provided, so the usage context is only implied.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safe read behavior is known. The description adds context about the hosted MCP endpoint and authentication requirements, but does not disclose return format, error scenarios, or state semantics beyond what 'state' implies.

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, tight sentence that states the action and parameter usage without unnecessary verbiage. 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?

While the description is adequate for a simple getter, it omits any details about the return value (what constitutes 'intake state'), and api_base_url is not mentioned. Without an output schema, this lack of context leaves some ambiguity for the 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 coverage is 75%, and the description reinforces the relationship between url and session_id/access_token, which is already partially described in the schema. It does not clarify api_base_url, and session_id lacks a schema description, so the description adds limited new meaning.

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

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

The description clearly states the tool fetches the current applicant intake state, using a specific verb and resource. It is distinct from sibling tools like get_case or open_intake, though it doesn't explicitly differentiate itself.

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

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

No guidance on when to use this tool versus alternatives like open_intake or get_case. The description only explains parameter combinations (url or session_id + access_token) for the hosted endpoint, not selection criteria.

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 idempotentHint=true, so safety is covered. The description adds the behavioral trait of polling (repeated calls expected) and indicates the response contains a status and result, which is useful 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 description is a single, front-loaded sentence with zero waste. It conveys the action, resource, and result type efficiently, earning its place without 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?

The tool is simple with only two parameters and no output schema, but the description does not mention return format, possible status values, error behavior, or how to use the result. Given the richness of annotations and the context of sibling tools, it is minimally sufficient but lacks operational details for an agent to fully anticipate the response.

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

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

The input schema has 0% description coverage and the description itself does not explain `case_id` or `command_id`. While the parameter names are somewhat self-explanatory, the description adds no meaning or context about their format, relationship, or how to obtain them, so it fails to compensate for the schema's lack of descriptions.

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

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

The description uses a specific verb 'Poll' and a clear resource 'status and result of an intake-review command', which clearly distinguishes it from sibling tools like `get_case` or `submit_case_review`. It unambiguously states what the tool does and its scope.

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

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

The word 'Poll' implies usage after initiating a review command, but the description does not explicitly state when to use this tool versus alternatives like `get_case` or `get_intake_state`. No exclusions or alternative tools are mentioned, so the usage guidance is implied rather than explicit.

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

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

Annotations declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the mutation/safety profile is partly covered. The description adds real value beyond that by disclosing the return value ('Returns the fresh intake state') and the dependency on next_action. It does not warn about re-invocation behavior despite idempotentHint=false, which keeps it from a 5.

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

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

Three short sentences, each doing work: the action, the invocation gate, and the return value, in that order. No filler.

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

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

For a mutation tool with no output schema, the description covers what it does, when it is legal to call, and what comes back. The remaining gap is idempotency/repeat-call behavior given idempotentHint=false, which an agent would benefit from knowing.

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 75%, so the schema already documents url, access_token, and api_base_url. The description adds no syntax or format detail for any of the four parameters, so it neither compensates for the uncovered session_id nor improves on the schema.

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

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

States a specific verb+resource ('Record the applicant's consent to processing') and distinguishes itself from siblings like submit_intake and save_intake_draft by scoping to the consent step. An agent can identify the operation 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?

Gives an explicit gating condition ('when the intake state's next_action is consent') and a precondition for invoking it ('only after the applicant has agreed to the notice in next_action.notice'). This is exactly the when-to-use guidance an agent needs to avoid firing it prematurely.

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

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

Annotations already declare the operation as read-only, non-destructive, and idempotent. The description adds useful context beyond these: it specifies the 'bounded' nature, environment scoping, and the required permission cases:review. This is valuable additional behavioral information without contradicting any 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 description is concise and front-loaded: two sentences that state the core action and the key requirement. Every word adds value, with no 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?

Given a simple tool with one parameter, good annotations, and no output schema, the description covers essential context: purpose, environment scoping, bounded nature, and permission. It doesn't detail the return format, but that's less critical for a straightforward list operation, and the annotations cover the safety profile.

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

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

The schema description coverage is 0%, meaning the description provides no explanation of the 'limit' parameter. Although the schema gives type and constraints (number, 1-200), the description doesn't compensate by explaining that 'limit' controls the maximum number of queue items returned. The parameter is named 'limit' and is fairly intuitive, but the description offers no semantic clarification.

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

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

The description clearly states the tool's action (List), resource (bounded Klarefi operator queue), and scope (for this API key's environment). This distinguishes it from sibling tools, none of which explicitly address operator queue listing.

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: it lists a bounded queue specific to the API key's environment and requires the cases:review permission. It doesn't explicitly name alternatives or exclusions, but no sibling tool serves the same purpose, so the context is sufficient.

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, covering the safety profile. The description adds useful domain context by specifying that these are 'versioned' declarations and identifies the 'Form · Fact · Verify' classification, which helps the agent understand what the tool operates on without contradicting 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, front-loaded sentence with no unnecessary filler. Every word adds meaning and it is immediately clear what the 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?

For a simple zero-parameter list operation with robust annotations, the description is adequate. It lacks details about return values or pagination, but given the simplicity and the absence of an output schema, the description covers the essential context.

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

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

The tool has zero parameters, so the baseline is 4. The description offers no parameter details, but none are needed since there are no inputs to explain.

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 specific verb 'list' and clearly identifies the resource as 'versioned Form · Fact · Verify workflow declarations', which distinguishes it from sibling tools like list_operator_queue or get_*. The qualifiers 'versioned' and 'Form · Fact · Verify' give precise scope.

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

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

The description implies that the tool is for listing workflow declarations, but it provides no explicit guidance on when to use it versus alternatives or any exclusions. There are no mentions of alternative tools or contexts where this tool is inappropriate.

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 and idempotent, and the description adds useful context: no API key required, and a credential reuse requirement for later calls. This supplements the annotation information 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 sentences, front-loaded with the core action, no redundant text. Every sentence provides value.

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

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

For a read tool with no required params and no output schema, the description covers the essential input selection and credentials. It could mention what is returned, but the name and purpose imply intake data.

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 75% and already describes most parameters. The description adds the key relationship that url OR session_id+access_token are alternatives, clarifying the mutual exclusivity not fully explicit in schema.

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

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

The description clearly states the tool reads an applicant intake, with two alternative authentication methods (signed URL or session_id+access_token). It distinguishes itself from sibling tools that create, submit, or save intakes.

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

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

Provides clear context on when to use: reading an intake via hosted or local endpoint. Includes specific guidance about credentials and the hosted endpoint, but does not explicitly mention alternatives or exclusions.

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

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

Annotations already indicate destructiveHint=true, readOnlyHint=false, and idempotentHint=false, so the description's disclosure burden is lower. It adds useful behavioral context by clarifying that the operation does not submit and that field values must be strings or null, but it does not explain the nature of the destructive behavior (e.g., overwriting existing drafts) or other side effects beyond what annotations imply.

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 unnecessary words. It front-loads the key action and constraint, making it easy to parse. 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?

Given the tool's moderate complexity (5 params, nested object) and high schema coverage, the description provides the essential context: purpose and a key constraint. It doesn't explain alternative parameter combinations (url vs. session_id/access_token), but those are described in the schema. The absence of an output schema also reduces the need for return-value details. Overall, it is sufficient for basic understanding, though slightly thin on side effects.

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 high (80%), so baseline is 3. The description adds significant meaning beyond the schema by specifying that field values must be strings or null, which is not stated in the fields property description (it only says 'additionalProperties: true'). This extra semantic guidance raises the score.

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

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

The description clearly states the tool's function: 'Save applicant form draft fields without submitting.' The verb 'save' and resource 'applicant form draft fields' are specific, and the phrase 'without submitting' distinguishes it from sibling tools like submit_intake. This makes the purpose immediately understandable and 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?

The description provides clear context: it is for saving draft fields without submission, implying use when the user wants to preserve progress without finalizing. However, it does not explicitly name alternative tools (e.g., submit_intake) or state when not to use it, so it falls short of full explicit exclusion guidance.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, idempotentHint=false, so the safety profile is covered structurally. The description adds genuine behavioral context beyond that — validation occurs on save, publishing/activation is out of scope, and omitted parameters fall back to the connector's default — though it never explains the destructive/overwrite risk that destructiveHint=true implies for an existing draft.

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, front-loaded with the action and its scope limit before the binding-format detail. Given the empty schema, the encoding sentence fully earns its place; there is no filler.

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

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

Returns are not explained, which is acceptable given no output schema, and the binding semantics are well covered. The main gap is structural: the sole required parameter is a free-form object with zero schema documentation, and the description does not sketch what a valid workflow declaration contains, leaving the agent unable to construct the input from this definition alone.

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

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

The schema is an untyped open object (additionalProperties: true, 0% description coverage, one nested object), so the description must carry the semantics — and it partially does by decoding input_bindings entry forms (fact ID, {literal}, {case}), flagging that literals must never be secrets, and stating default behavior for omitted parameters. It stops short of describing the rest of the workflow declaration's shape.

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

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

Specific verb+resource ("Validate and save a workflow declaration as a draft") plus a scope limit ("cannot publish or activate"). It does not name or differentiate against any sibling tool (e.g. save_intake_draft, list_workflows), so the reader must infer which draft-saving tool applies from the noun alone.

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

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

Provides a clear when-not ("cannot publish or activate the workflow"), which steers an agent away from expecting a live deployment. However it names no alternative tool for actually publishing/activating, and gives no preconditions (e.g. a draft must first exist, or how to discover one via list_workflows).

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

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

Annotations already flag destructiveHint=true and idempotentHint=false, and the description adds meaning beyond them: the command is auditable, it cannot complete or reopen a case, and a premature decision is latched until applicable (asynchronous behavior). It does not describe side effects on case state per command type, but the addition is substantive.

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

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

Four tight sentences, front-loaded with the core action, then constraints, then the checks_go special case. The middle sentence is dense and reads slightly run-on, but nothing is padding.

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

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

For a destructive, non-idempotent mutation with no output schema and 0% schema coverage, the description leaves notable gaps: what a successful submission returns, whether idempotency_key prevents duplicate commands, and what permissions or preconditions apply. It covers enough to start but not enough to call confidently.

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

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

Schema description coverage is 0%, so the description must carry the load. It explains payload.decision values and the optional rationale for checks_go, and loosely maps the enum to concepts, but says nothing about case_id, trace_id, idempotency_key, or the payload shape for approve_fact/correct_fact/escalate.

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 (submit an auditable intake-review command) and enumerates the allowed command families: review/correct facts, update evidence, escalate, checks_go. It also draws a hard boundary (cannot complete or reopen a case), which sharpens what the tool is not.

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

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

Gives concrete operating guidance for the trickiest path: for checks_go supply payload.decision as go/not_now/withdraw and poll get_review_command, plus a warning that a decision sent before case start stays accepted until it applies. Missing is general guidance on when to choose this over sibling intake tools like submit_intake or answer_question.

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

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

Annotations already declare destructiveHint: true and readOnlyHint: false. The description adds return-value information but does not disclose behavioral traits such as irreversibility, prerequisite conditions, or side effects beyond what the annotations already 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 two short sentences, front-loaded with the core action, and contains no redundant information. 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?

Given the tool has 5 parameters, nested objects, no output schema, and is destructive, the description is thin. It mentions return values but not their structure, nor prerequisites or side effects. It is minimally sufficient but leaves gaps for an agent to infer.

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

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

Schema description coverage is 80%, so the schema already documents most parameters. The description adds no parameter-level detail, but the baseline of 3 is appropriate given the high 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?

The description uses the specific verb 'submit' with the resource 'applicant intake', clearly distinguishing it from sibling tools like 'save_intake_draft' and 'open_intake'. It also states the return value ('submitted, blockers, and the fresh intake state'), which clarifies the outcome.

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 is the final action for an intake, contrasting with 'save_intake_draft', but it does not explicitly state when to use it or mention alternatives. The usage context is only implied, not fully specified.

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:false and destructiveHint:false, so the description does not need to restate that this is a write operation. The description adds valuable behavioral details beyond annotations, such as the 5MB and 25MB size limits, the requirement to include url on every hosted call, and the fact that api_base_url is ignored on hosted. These specifics help an agent anticipate behavior without relying on annotations alone.

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, using only three sentences. It front-loads the main purpose and then packs in usage constraints efficiently. Every sentence contributes essential information—purpose, parameter selection, and size limits—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?

Given the tool has 9 parameters and no output schema, the description explains the main execution modes and size limits, but it does not describe the return value, success/error indicators, or how to handle failures. It also leaves several parameters unexplained. While the description covers the core usage well, the absence of output semantics and some parameter details makes it only partially complete.

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

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

With schema description coverage at only 44%, the description compensates by clarifying key parameter relationships: content_base64 for hosted, file_path for local, filename defaulting to basename, and api_base_url being local-only. It also explains size constraints tied to these parameters. This adds significant meaning beyond the raw schema, though some parameters (task_id, session_id, mime_type) remain under-explained.

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

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

The description uses a specific verb ('Upload') and a clear resource ('requested applicant document'), making the tool's purpose immediately obvious. This clearly distinguishes it from siblings like submit_intake or save_intake_draft, which focus on other actions. The phrase 'requested applicant document' also suggests a precise context, enhancing clarity.

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 guidance on how to use the tool in different environments (hosted MCP vs. local stdio) and which parameters to use accordingly. However, it does not explicitly mention when to use this tool over alternative tools, or when not to use it, leaving some ambiguity for an AI agent. The environment-specific instructions are useful but not a full replacement for explicit usage boundaries.

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 idempotentHint=true. The description supplements this by revealing the polling loop and timeout behavior, which is valuable context. No contradiction exists with annotations.

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

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

The description is extremely concise—two sentences—with the primary action front-loaded. Every word earns its place, containing no fluff or repetition.

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

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

The description covers the core behavior (polling condition, timeout handling) and hints at the response via 'timed_out'. However, it does not describe the full response shape or provide guidance on parameter usage, leaving some gaps for a read-only polling 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 60%, leaving session_id and timeout_seconds undocumented. The description does not explain any parameters or add meaning beyond the schema, failing to compensate for the missing 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 clearly states the tool's function: 'Poll until the intake leaves processing or the timeout expires.' This specifies a unique verb (poll), resource (intake), and condition, distinguishing it from sibling tools like get_intake_state or submit_intake.

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

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

The description provides clear usage context by defining when to poll and how to handle timeouts ('If timed_out is true, call wait_for_next_action again'). However, it does not mention alternatives or when not to use this tool, so it falls short of explicit exclusion guidance.

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