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

With no annotations, the description carries the full behavioral burden, but it only says 'create' and offers no side-effect, permission, validation, idempotency, or failure-mode information. It implicitly signals mutation but does not disclose consequences such as whether connector_id is required or what happens on duplicate names.

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 concise and front-loaded, but it is severely under-specified for a tool with six parameters and no annotations. It resembles the 'Process' case where brevity is more under-specification than genuine conciseness.

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

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

Given no output schema, no annotations, and a six-parameter input, this description is far too sparse to support correct invocation. It omits even basic context about required inputs, connector usage, activation status, and expected results.

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

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

The description does not mention any of the six parameters. Schema coverage is only 50%, so status, description, and connector_id are undocumented in both the schema and the description, and the required name/type semantics are not enriched either.

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 has a specific verb ('Create') and resource ('integration'), which clearly states the primary action. It differentiates from sibling tools such as update_integration by the create/update contrast, though it provides no details about what an integration is or how it relates to connectors.

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 for when to use this tool over alternatives. The description does not mention that creation is for new integrations while update_integration applies to existing ones, nor does it state any prerequisites or 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses the primary side effect ('Create') and the return value ('new process_id'), but does not mention important behavior such as default status, whether creation is idempotent, required permissions, or side effects on related entities. For a mutation tool with no annotation coverage, this is a notable gap.

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

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

The description is a single, front-loaded sentence that immediately states the action, resource, and return value. Every word earns its place, and there is no redundant repetition of the tool name or title.

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

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

The tool has 12 parameters, a nested object in configuration, no output schema, and no annotations, yet the description only states the basic creation action and return value. Most of the schema properties lack descriptions, and the description provides no context on required fields, defaults, parameter semantics, or how the created process relates to the process lifecycle. This is far from complete for an agent to use the tool correctly.

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

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

Schema description coverage is only 8%, and the description does not compensate by explaining any of the 12 parameters. The only described parameter behavior comes from the schema's name field and status enum, while the description itself adds zero input semantics. With such low coverage and no compensating description, an agent is left without meaningful guidance 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 description clearly states a specific action ('Create') on a specific resource ('a new Tealfabric process') and notes the return value ('Returns the new process_id'). It is not a tautology and distinguishes the tool from unrelated siblings like connectors and documents, though it does not explicitly contrast with process-related siblings like update_process or create_process_step.

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 a new process needs to be created. However, it provides no explicit guidance about when not to use it or what alternatives exist, such as using create_process_step for steps or update_process for modifying an existing process. The usage context is clear but not enriched with exclusions or decision rules.

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?

No annotations are provided, so the description carries the full behavioral burden. It does disclose that the tool creates a resource and returns the new step_id, which is core behavioral information. But it does not mention side effects, validation, defaultes like step_type, or whether the process_id must refer to an existing process. Some helpful behavioral context is missing, but the core mutation and outcome are clear.

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, front-loaded sentences contain no filler. The first states the action and resource; the second provides return information not available in the structured data. Both sentences earn their place.

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

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

This is a 15-parameter tool with nested objects, no annotations, and no output schema. The description covers only the high-level purpose and return value, leaving substantial context unexplained—how steps are ordered/positioned, what step_type defaults to, whether process_id is validated, and how schema/config fields are used. That is too incomplete 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 20%, and the description does not compensate for the 15 undocumented parameters. It explains nothing about sequence, step_type, position_x/y, configuration, input/output schemas, or the alias relationship between name and step_name. For an agent to select correct parameter values, this is a critical gap.

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

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

The description states a specific action ('Create') and resource ('new process step') and even names the return value ('Returns the new step_id'). This clearly distinguishes it from sibling operations that update, get, list, or execute process steps. The purpose is unmistakable even 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?

It implies use when a new process step needs to be added to a process flow, which is clear context. However, it gives no explicit guidance about when not to use it or when to prefer siblings like tealfabric_update_process_step or tealfabric_list_process_steps. The usage is implied rather than 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?

With no annotations provided, the description carries the behavioral disclosure burden. It correctly conveys the mutating action of creation and the return of a new webapp_id. However, it does not mention lifecycle implications, such as whether the webapp is immediately visible or must be published separately, nor any permissions or constraints.

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

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

The description is two short sentences with no filler. It front-loads the core action and immediately provides the key return 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?

For an 8-parameter creation tool with no annotations, no output schema, and only 25% schema description coverage, the description is too thin. It provides the action and return ID but leaves agents without guidance on the many optional parameters and their impact on the created webapp.

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

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

Schema description coverage is only 25%, and the tool description adds no parameter-level meaning beyond the word 'webapp'. Six parameters such as custom_js, custom_css, page_footer, page_header, and page_content have no descriptions in the schema and are not explained in the tool description.

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

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

The description states a specific verb ('Create'), a specific resource ('new Tealfabric webapp'), and the expected return value ('the new webapp_id'). This clearly distinguishes it from sibling tools like tealfabric_list_webapps, tealfabric_get_webapp, tealfabric_update_webapp, and tealfabric_publish_webapp.

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 the tool is for creating a new webapp rather than updating, listing, or publishing one. It does not explicitly name alternatives or exclusion cases, but the create-only context is unambiguous.

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

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

With no annotations, the description must carry behavioral transparency; 'Delete' plainly indicates a destructive operation on the target file or directory. However, it does not disclose whether directory deletion is recursive, whether deletion is permanent/recoverable, or what happens on missing paths, which are material gaps for a delete tool.

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

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

The description is one short sentence with no filler or repetition; it delivers the action and resource immediately. 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 simple delete tool, the core purpose and parameters are covered, but the lack of annotations and output schema leaves important operational details unstated, especially the semantics of deleting a directory. The tool is minimally usable but not fully contextualized for an agent deciding whether deletion is safe or recursive.

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 path as the file/directory to delete and tenant_id as defaulting to the authenticated tenant. The description adds no parameter-level meaning beyond the schema, so the baseline 3 applies.

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

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

Description opens with an imperative verb and narrow resource: 'Delete a file or directory from Tealfabric documents storage.' It is specific about both action and target, and the deletion action is distinct from sibling document operations like upload, download, and move.

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 it clear that this tool is for removing files or directories from document storage, which is unambiguous against the sibling tools. It does not enumerate exclusions or alternatives, but no alternative deletion sibling exists, so the core usage 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It usefully reveals that file content is base64-encoded for binary-safe transfer, which is meaningful behavior beyond the schema. It does not mention auth, errors, or size limits, but for a read-only download the most important behavior is captured.

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 states the operation and the critical return format. There is 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?

The tool is simple, the schema fully documents both parameters, and the description supplies the return-format detail that would otherwise be missing given the absence of an output schema. Minor gaps like error behavior or tenant default handling are not critical for a basic download operation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add further meaning to file_path or tenant_id beyond what the input 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 uses a specific verb ('Download') and names the resource ('document/file from Tealfabric documents storage'), and it adds the key detail that the file content is returned as base64. This clearly distinguishes the tool from siblings like get_document_metadata or list_documents.

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 imperative 'Download' makes the intended use obvious, and mentioning base64 output helps an agent choose this tool when raw file content is needed. It does not explicitly name alternatives or exclusions, but the context is clear enough for a straightforward retrieval 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?

With no annotations available, the description carries the full burden of disclosing behavior, but it only says 'execute' and ignores whether execution is synchronous or asynchronous, whether it returns a run result or job ID, whether it can fail at runtime, or what side effects it may cause. It offers almost no behavioral detail beyond the verb itself.

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 clear sentence with no filler words. It front-loads the core action and includes the key modifier about optional input, which is appropriately concise.

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

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

For an execution tool with no output schema and no annotations, the description is too sparse. It does not mention what the response will contain, whether the process runs asynchronously, or what happens when the process_id is invalid, leaving important operational context missing.

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

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

Schema description coverage is 100%, so process_id and input are already documented. The description adds only the word 'optional' for input, which reinforces the schema but provides no additional detail about the expected shape of the input payload.

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 ('Execute') and resource ('a Tealfabric process'), and clarifies that input is optional. The action is distinct from sibling tools like list_processes, get_process, create_process, and update_process, so the agent can identify this as the run/trigger operation.

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, such as needing an existing process before execution or that get_process/list_processes are for inspection rather than running. The description implies that execution is the use case, but provides no contextual direction.

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

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

With no annotations, the description carries the behavioral burden. 'Check whether' strongly implies a read-only predicate with no mutations, which is helpful. However, it does not disclose whether the check invokes external connector metadata, how failures are reported, or what the exact response shape is.

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 wasted words. It states the subject, the action, and the condition being checked efficiently.

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 single-parameter predicate, the description is nearly complete: an agent can infer the likely boolean result from 'whether.' It does not describe exact return values or error behavior, but the low complexity and full schema coverage make that omission minor.

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 already fully documents connector_id as a string with description 'Connector ID' and 100% coverage. The description adds no extra semantic detail about the parameter, so the baseline 3 applies.

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

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

The description clearly states the purpose: checking whether a connector requires OAuth2 authentication, with a specific verb and resource. It does not explicitly distinguish itself from tealfabric_list_connectors or tealfabric_test_connector, but its intent is unmistakable.

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

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

No guidance is provided about when to use this tool versus alternatives such as tealfabric_test_connector or tealfabric_list_connectors. The description implies a simple conditional check but does not state eligibility, context, 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Get metadata' implies a read-only operation, but the description does not disclose what happens for missing files, what metadata fields are returned, whether tenant resolution affects behavior, or any error 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 one short sentence that front-loads the purpose and contains no filler. It is appropriately concise, though it sacrifices some useful behavioral context for brevity.

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

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

For a simple read tool with fully documented parameters, this definition is minimally workable: the agent knows the intended operation and has file_path guidance via the schema. However, because there is no output schema and no annotation, the return contents, error behavior, and edge-case handling are left unspecified.

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 file_path with an example and tenant_id with its default. The tool description adds no additional parameter-level meaning beyond referring to the target as a 'document/file,' so the baseline score 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 states a clear action and resource: 'Get metadata for a document/file in Tealfabric documents storage.' It distinguishes this from sibling tools like download, upload, move, or delete by focusing on metadata retrieval. It does not enumerate what metadata is returned, but the core purpose is unambiguous.

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

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

No usage guidance is provided. The description does not explain when to use this tool instead of tealfabric_list_documents or tealfabric_download_document, nor does it mention preconditions such as the file needing to exist.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. 'Get' clearly signals a read-only retrieval operation with no side effects, which is sufficient for a simple getter. It does not mention error behavior or return format, but nothing suggests hidden mutation or 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 a single, focused sentence that conveys the essential purpose without any filler. It front-loads the action and resource, and every word contributes meaning.

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

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

Given the tool's simplicity—one required parameter and a singular get operation—the description is adequately complete for selecting and invoking it. It does not explain return structure or failure modes, but the lack of output schema and minimal complexity make the description sufficient.

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

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

The schema covers the single parameter fully with a description ('Process ID'), and the tool description aligns with it by saying 'by ID'. The description adds no extra semantic detail beyond what the schema already provides, so the baseline score 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 verb ('Get'), a specific resource ('a single Tealfabric process'), and the identifying input ('by ID'). It clearly distinguishes this from sibling tools like tealfabric_list_processes and tealfabric_get_process_step.

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 conveys that this tool is for retrieving one specific process when its ID is known, as opposed to listing processes. It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to select appropriately.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention error behavior, response shape, authentication, or whether the step definition is returned in full; 'Get' mostly restates the tool 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 a single tight sentence with no filler. It front-loads the action and resource, making it easy for an agent 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?

The tool is simple with one required parameter, and the description is adequate for basic invocation. However, with no output schema and no annotations, the agent is left without details on return structure, not-found behavior, or how the step_id relates to list_process_steps.

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 step_id property is already documented as 'Step ID'. The description adds no additional semantic detail beyond the schema, so the baseline score 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 states a specific action ('Get'), a distinct resource ('a single process step'), and the lookup key ('by step_id'). This clearly distinguishes it from sibling tools like tealfabric_list_process_steps and tealfabric_get_process.

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 implies the right context: use when you have a concrete step_id and need one specific process step. It does not explicitly mention when not to use it or point to list_process_steps for discovery, so no full when/when-not guidance is given.

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

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

No annotations are provided, so the description must carry the burden of behavioral disclosure. It indicates a read-style retrieval operation and the option to request a specific version, but it does not mention response format, version default behavior, or error conditions. This is acceptable for a simple getter but leaves some room for interpretation.

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 carry exactly the needed information, with the core operation front-loaded and the optional version behavior stated separately. Every sentence earns its place with no 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 straightforward single-resource getter with two fully documented parameters and no output schema, the description is sufficient for an agent to call the tool correctly. It could mention return behavior, but the operation's simplicity makes that a minor 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 100%, so the schema already documents both parameters. The description restates the ID and version concepts but adds no semantics beyond what the schema provides, matching the baseline for fully covered schemas.

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

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

The description states a specific verb ('Get'), a resource ('Tealfabric webapp'), and a selection mechanism ('by ID'), clearly distinguishing it from list, create, update, and publish sibling tools. The optional version qualifier adds precision without ambiguity.

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 conveys that this tool is for fetching a single webapp when an ID is known, which implies when to use it over list_webapps or other sibling operations. It does not explicitly name alternatives or exclusion conditions, but the context is clear enough for correct 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?

No annotations are provided, so the description must carry the behavioral disclosure burden. The verbs 'list', 'get', and 'fetch' communicate read-only intent, but the description does not explicitly state that nothing is mutated, describe return/output behavior, or address the 'when supported' caveat around connector_id.

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

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

A single sentence with no filler; the three operations are presented in a compact, parallel structure. It is appropriately sized relative to the tool's simple 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?

For a tool with zero required parameters and complete schema coverage, the description provides enough to attempt a basic call. However, it leaves gaps around return format, whether get and parameters both require connector_id, and how this tool relates to connector siblings.

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 baseline is 3. The description aligns with the action and connector_id parameters but adds little semantic detail 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?

Names Tealfabric connectors as the resource and uses distinct verbs for each mode: 'list', 'get', 'fetch'. However, the tool is named list_connectors yet the description covers three different actions and does not differentiate itself from sibling connector-related 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 supported operations are implied by the description and the schema's 'omit to list all' note provides basic usage context. But there is no explicit guidance on when to use this tool instead of alternatives such as tealfabric_test_connector or tealfabric_get_connector_oauth2_required.

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?

No annotations are provided, so the description carries the full behavioral disclosure burden. It says the tool lists items but does not disclose return shape, pagination, sorting, recursive behavior, permissions, or whether it is purely read-only. These gaps matter for a tool with no output schema.

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

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

Two short sentences, front-loaded with the main action, and no filler. Every word adds value. The one slight redundancy ('documents/files') does not materially hurt 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 simple list tool with no output schema and no annotations, the description adequately states the core purpose but omits details about the response format and listing behavior. That leaves the agent with some uncertainty about what exactly will be returned.

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

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

Schema description coverage is 100%, so the schema already documents both `path` and `tenant_id` well. The description adds only the high-level context that this is about browsing package files, which does not meaningfully extend the parameter semantics. Baseline 3 is appropriate here.

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 ('List') and a clear resource ('documents/files in a Tealfabric documents directory'). It also states the primary use case ('browsing package files'), which separates it from document operations like download, upload, or metadata retrieval among the siblings.

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

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

Directly states when to use the tool: 'Use for browsing package files.' This gives clear contextual guidance, even though it does not explicitly name alternatives or exclusions. For a simple listing tool this is sufficient to route an agent.

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

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

No annotations are provided, so the description must disclose behavioral traits. It describes the tool as query-style ('list', 'query'), but the schema includes a 'test' action that may execute a test run and have side effects—this action is omitted from the description. The description also does not clarify that behavior varies significantly by action, which is critical for safe invocation.

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 front-loads the primary purpose and then expands to additional capabilities. It contains no filler, though the list 'details/status/statistics/execution history' is somewhat compressed. Overall, it is appropriately sized.

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 multi-action tool with 12 parameters, no output schema, and no annotations. The description is far too sparse to be complete: it does not clarify what each action returns, which parameters are required or relevant per action, or whether 'test' has side effects. An agent would need to reason through schema enum descriptions and guess at usage patterns.

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 42% schema description coverage and 12 parameters, the description needed to compensate, but it only vaguely mentions 'action filters.' It does not explain which parameters apply to which actions, or how pagination, sorting, and filtering work. The action parameter is already described in the schema, so the description adds little beyond that.

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 lists integrations and can query details, status, statistics, and execution history through action filters. The verb and resource are specific, and the multi-action nature is mentioned. It does not explicitly distinguish itself from sibling list tools, but the resource name 'integrations' makes the distinction obvious.

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 tool to list or query integration-related data. However, it provides no explicit guidance on when to prefer this over alternatives like tealfabric_list_connectors, nor does it explain when each action filter should be chosen. The context is present but not fully developed.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It indicates a read-style listing operation scoped to the authenticated tenant, which implies no mutation, but it does not address pagination, result shape, or potential side effects. This is adequate but minimal.

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 the action and object front-loaded. Every word contributes meaning, and 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?

For a zero-parameter read-only list operation, the description provides the essential information needed to call the tool correctly: what is listed and for whom. It could be more complete by noting the expected return format, but the core invocation context is present.

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 is empty with 100% description coverage, so there are no parameters to document. The description usefully clarifies that the tenant context is implicit rather than passed as a parameter.

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

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

The description clearly identifies the verb ('List'), the resource ('Tealfabric ProcessFlow processes'), and the scope ('for the authenticated tenant'). This distinguishes it from sibling tools like tealfabric_get_process (which targets a single process) and tealfabric_create_process (which creates rather than lists).

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 no guidance on when to use this tool versus alternatives such as tealfabric_get_process or tealfabric_list_process_steps. It does not mention exclusions, ordering, or scenarios where another tool should be chosen.

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?

No annotations are provided, so the description carries the behavioral disclosure burden. It only says 'list', which implies a read operation, but omits details such as ordering, pagination, error behavior, or what constitutes a process step. It adds little beyond the tool 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 a single, compact sentence with no filler and the core action is front-loaded. It is clear and appropriately brief for such a simple tool, though it sacrifices some behavioral detail for brevity.

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

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

For a single-parameter list operation with no output schema, the description is minimally sufficient: an agent knows to supply process_id. However, it does not explain what process steps are, what the response contains, or any special behavior, leaving some gaps.

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

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

Schema description coverage is 100% and the only parameter, process_id, is already described as 'Process ID'. The tool description adds minimal meaning beyond that, so it meets the baseline for 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 clearly states the action (list), the resource (process steps), and the scope (for a given process). It does not explicitly differentiate from siblings like get_process_step, but the plural resource and list verb make the purpose reasonably distinct.

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 list_processes, get_process_step, or execute_process. The phrase 'for a given process' implies usage context, but no exclusions or selection criteria 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?

With no annotations, the description carries the full burden. It adds useful context about tenant scoping and optional filtering, but does not explicitly confirm the operation is read-only (no mutation of webapps), nor disclose return shape or pagination behavior. 'List' implies safety, but that implication is not stated.

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

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

One tight sentence that frot-loads the action and resource, then states scope and optional filters. Every word contributes; there is no repetition, fluff, or buried 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?

The tool is low-complexity with 0 required params and full schema coverage, so invocation is well-specifed. However, with no annotations and no output schema, the description does not disclose return format, whether results are paginated, or the explicit read-only nature -- gaps that matter when the description is the only behavioral signal available.

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%: both limit and search are fully described in the schema. The description merely restates what the schema already says ('Optionally fileter by search or limit'), adding no extra semantic value. Baseline 3 applies because the schema does the heavy lifting.

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

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

The description uses a specific verb ('List') and resource ('webapps') with clear scope ('for the authenticated tenant'). The plural 'webapps' combined with 'List' differentiates it from siblings like tealfabric_get_webapp (singular retrieval) and the mutation tools (create/update/publish), so an agent can pick it confidently.

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 -- listing webapps is distinguishable from getting/creating/updating/publishing one -- but it never explicitly states when to choose this over alternatives. There is no when-not-to-use guidance or named sibling, leaving the agent to infer routing from the tool-name convention 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?

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It mentions that the tool moves or renames files/directories, but it does not disclose whether existing destination paths are overwritten, whether directory moves are recursive, whether permissions are required, or what side effects may 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 two concise sentences with no filler. The action is front-loaded, and the additional use-case sentence earns its place by helping with tool selection.

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 3 parameters, no annotations, and no output schema, the description gives the essential operation and purpose. However, it omits important behavioral context such as overwrite policy and implications of moving directories, so it is adequate but not complete for edge cases.

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

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

Schema description coverage is 100%, so the schema already documents old_path, new_path, and tenant_id. The description adds no extra parameter-level detail beyond the schema, which fits the baseline for fully covered schemas.

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

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

The description states a specific verb ('Move or rename'), a clear resource ('file/directory in Tealfabric documents storage'), and concrete use cases. It is also the only move/rename tool among the siblings, so an agent can distinguish it clearly.

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 provides explicit usage context: 'Use to update package paths or reorganize.' It does not name alternatives or exclusions, but no sibling tool provides a comparable move/rename operation, so the guidance 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal that publishing promotes the current version to live, which is useful, but it omits side effects, reversibility, permissions, or whether the previous live version is replaced. This is minimal behavioral transparency for a mutating operation.

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

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

The description is a single, tightly worded sentence with no filler. The core action and its clarifying effect are both front-loaded, making it easy for an agent 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?

The tool is simple, with one schema-documented parameter and no output schema, so the description does not need to explain return values. However, because annotations are absent, the description could have more explicitly captured behavioral context such as irreversibility or the fact that this is a deployment action affecting the live environment.

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 single parameter 'webapp_id' is already documented as 'Webapp UUID.' The description adds no additional parameter-level meaning, which is acceptable given the schema fully covers the parameter.

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

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

The description uses a specific verb ('Publish') tied to a clear resource ('Tealfabric webapp') and immediately clarifies the intended effect with the parenthetical 'make the current version live.' This distinguishes it from sibling tools like list, create, update, or get webapps.

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 explains what the tool does but gives no explicit guidance on when to choose it over alternatives, when not to use it, or what prerequisites or sequencing might apply (e.g., requiring a previous update before publishing). Usage context is only implied by the phrase 'make the current version live.'

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that it 'tests' a payload against an endpoint, but does not disclose whether the test is read-only, makes an external network call, or creates any temporary resources. This is a minimal statement rather than transparent behavioral documentation.

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 declarative sentence with no filler. The action and object are front-loaded, and every word contributes directly to understanding 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?

Given one required parameter, no output schema, and no annotations, the description is functional but sparse: it does not tell the agent what result to expect, what a failed test looks like, or whether the test has side effects. For a low-complexity tool this is close to adequate, but there are clear gaps.

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

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

The input schema already documents payload with 100% coverage as 'Connector configuration payload expected by the selected connector'. The description adds no new parameter-level detail beyond naming the endpoint, so the baseline of 3 for high schema coverage 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 the clear verb 'Test' and names the exact resource ('connector configuration payload') and the specific endpoint ('Tealfabric connectors test endpoint'). It does not explicitly contrast with sibling tools like list_connectors or execute_process, but the action and object are specific enough that an agent can infer its distinct role.

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, such as validating a connector configuration before creating an integration, or any prerequisites like fetching the connector list first. The intended usage context must be inferred entirely from the tool name, which is minimal.

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?

No annotations are provided, so the description carries the full disclosure burden. It only says 'Update an existing integration,' without explaining whether fields are partially or fully replaced, idempotency, required permissions, side effects, or what happens if the integration_id does not exist.

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

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

The description is a single sentence with no wasted words, but it is under-specified rather than efficiently concise. It conveys the core action without elaboration, which is too thin for a 7-parameter mutation tool.

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

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

For a tool with 7 parameters, no output schema, and no annotations, this description is far from complete. An agent cannot determine which fields are updatable, whether inputs are validated, what the response looks like, or how this update behaves.

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

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

Schema description coverage is only 14%, with only integration_id documented in the schema. The description adds no meaning for name, type, status, is_active, description, or connector_id, leaving six parameters semantically opaque.

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

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

The description states a clear verb ('Update') and resource ('an existing integration'), and the word 'existing' distinguishes it from tealfabric_create_integration. However, it mostly restates the tool name and does not list which fields are updatable.

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 about when to use this tool versus alternatives like tealfabric_create_integration or tealfabric_list_integrations. There are no conditions, prerequisites, or exclusion criteria 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that an existing process is updated, without explaining whether the update is a partial patch or full replacement, what effects it has on running processes, whether versioning is involved, or what response to expect. This is a significant gap for a mutating operation.

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

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

The description is a single concise sentence with no filler or redundancy. It front-loads the action and resource immediately, making it easy to scan and understand at a glance.

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 13 parameters, a nested configuration object, no output schema, and no annotations, the description is far too minimal to be contextually complete. It fails to mention which fields are updatable, whether any combination is required, or what the operation returns. For a complex mutation tool, this description leaves major gaps.

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

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

Schema description coverage is only 8%, and the description adds no parameter-level meaning. None of the 13 parameters are mentioned or explained in the description, so it does nothing to compensate for the overwhelmingly undocumented schema. The agent gets no help understanding fields like configuration, status, or is_template beyond their raw 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 ('Update') and resource ('existing Tealfabric process (process flow)'), clearly distinguishing it from related operations like create, execute, or list. The phrase 'existing' reinforces that this is a mutation of an already-created process, not creation.

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 no guidance about when to use this tool versus alternatives such as tealfabric_create_process or tealfabric_execute_process. There are no stated conditions, prerequisites, or exclusions, so an agent must infer usage entirely from the tool name and general update semantics.

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

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

With no annotations, the description must disclose the tool's behavior on its own. 'Update' signals mutation, but the description does not reveal whether updates are partial or full replacements, what happens to omitted fields, what authentication or permissions are needed, or what the response contains. This is a significant transparency gap for a mutating tool.

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

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

The description is one concise, front-loaded sentence with no wasted words. Its brevity is a strength, but it is too terse to carry the needed operational context for a 15-parameter mutation tool.

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

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

This is a 15-parameter mutation tool with no annotations, no output schema, and only about 13% schema description coverage. A single generic sentence is grossly insufficient for an agent to understand required fields, update semantics, parameter semantics, or expected results.

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

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

Only 13% of the schema parameters have descriptions, and the tool description adds no parameter-level meaning. It does not explain the role of step_id, the updateable fields, or how the nested objects behave. The description completely fails to compensate 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?

The description states a specific verb ('Update') with a specific resource ('existing process step in a process flow'). It clearly differentiates from create/get/list siblings by emphasizing existing and by using the process-step resource rather than the process-level 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 wording implies use when modifying an existing process step, which is a clear context. However, it does not explicitly mention when to use alternatives like create_process_step for new steps or get/list_process_steps for reads, so the 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?

With no annotations, the description carries the full burden of disclosing behavior, but it only says 'Update' and gives examples. It does not state whether updates are partial or full, what happens to omitted fields, or whether any side effects 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 efficient sentence with the key action and resource front-loaded. It contains no filler, though the 'e.g.' phrasing makes the set of updatable fields slightly vague.

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

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

For a 9-parameter mutation tool with no annotations and no output schema, the description is too sparse. It fails to clarify which fields are commonly updated, how process_id nullability works, or what response the agent should expect.

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 11%, with only webapp_id documented. The description names page_content and name, but leaves the semantics of custom_js, custom_css, process_id, description, page_header, and page_footer entirely unexplained, so it does not compensate for the coverage gap.

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

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

The description clearly identifies the action as 'Update' and the resource as 'an existing Tealfabric webapp,' with examples 'page_content, name.' This distinguishes it from creation and retrieval tools, though it does not explicitly name sibling alternatives.

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

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

No explicit guidance is given about when to use this tool versus create_webapp or publish_webapp. The word 'existing' implies the resource must already exist, but there is no mention of prerequisites, 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?

With no annotations provided, the description carries the behavioral burden. It discloses that the file is stored in destination_path using the uploaded file's name, which clarifies the destination behavior. However, it does not mention overwrite behavior, permissions, side effects, or return/error information, which are meaningful gaps for an upload operation.

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

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

Two sentences with no filler. The primary action and intended use case are front-loaded, and the storage behavior is stated immediately after.

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 relatively simple upload tool, the description plus fully documented schema is mostly complete. It communicates purpose, destination semantics, and filename behavior. Missing details such as success/failure responses or overwrite behavior would improve completeness, but the tool is low-complexity and usable as described.

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 parameters are already well documented. The description adds little beyond the schema, mainly reinforcing the destination_path behavior and the file-name preservation already present in the property descriptions.

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

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

States a specific verb ('Upload') and resource ('Tealfabric documents storage'), and adds the intended use case of publishing built package files for delivery. It is clearly distinguishable from sibling document tools like download, move, delete, and 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 explicit context: use this to publish built package files for delivery. It does not explicitly state when not to use it or name alternative tools, but the purpose is clear enough for an agent to select it for upload-related tasks.

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