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

Annotations are absent, so the description carries the full burden of behavioral disclosure. It does reveal that the tool mutates tags and metadata and derives display identity from native end_user, but it does not disclose whether existing tags/metadata are overwritten or merged, whether patchMetadata affects this, what permissions are needed, or whether the operation is reversible or idempotent.

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 economical sentence with no fluff and the core phrase 'Apply suggested tags and metadata' is front-loaded. However, for an eight-parameter mutation tool, the terseness becomes under-specification rather than effective conciseness, leaving too much unsaid.

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 eight parameters, no annotations, and only a short description, the tool is not contextually complete. It does not explain what a 'convention' is in this domain, how required parameters relate to behavior, what happens to existing tags/metadata, or how patchMetadata and oauthAppOwner factor in. The output schema is present, so return values need not be described, but the operational context is still critically incomplete.

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

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

Schema description coverage is 0%, so the description must compensate for eight undocumented parameters. It only gestures at one concept ('native end_user' possibly mapping to principal) and vague 'tags and metadata', but does not explain environment, connectionId, providerConfigKey, ownerKind, purpose, oauthAppOwner, or patchMetadata. This is inadequate for a tool with six required parameters.

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

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

The description states a specific action ('Apply'), a resource ('suggested tags and metadata'), and an additional behavior ('deriving display identity from native end_user'). This distinguishes it from sibling tools like replace_connection_tags, update_connection_metadata, and build_connection_convention, since it combines these concerns and explicitly mentions identity derivation.

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 no guidance on when to use this tool versus alternatives. It does not mention describe_connection_convention, build_connection_convention, replace_connection_tags, or update_connection_metadata, nor does it state conditions or exclusions. The usage context must be inferred entirely from the name and description.

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

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

With no annotations, the description must carry all behavioral disclosure, but it only says 'Audit'. This implies read-only analysis, yet it does not state whether connections are modified, what is actually checked, or what side effects might occur. The presence of an output schema helps structure return values but does not disclose behavior.

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

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

The description is a single economical sentence with the verb and resource front-loaded and no filler. It could be more structured about outcomes, but it 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?

The tool has only two parameters and an output schema, but the description still omits parameter semantics and usage context. An agent would not know what environment values are valid, what 'audit' checks, or what constitutes a convention violation. This is insufficient for a tool with no annotation support.

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

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

Schema description coverage is 0%, and the description mentions neither 'environment' nor 'limit'. The schema only provides names and types, so an agent cannot know valid environment values or what the limit parameter controls. There is no compensating detail in the description.

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

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

States a distinct action ('Audit') on a specific resource ('Nango connections') with a clear focus ('suggested MCP tag/metadata conventions'). It is distinguishable from sibling tools like build_connection_convention and apply_connection_convention, though it does not define exactly what an audit result looks like.

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 run an audit versus using sibling tools such as describe_connection_convention, build_connection_convention, or apply_connection_convention. There are no exclusions, prerequisites, or alternative conditions 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 of disclosing side effects and behavior. 'Suggested' hints that the tool does not apply changes, but the description never states that it is non-persistent, read-only, or side-effect free, and it says nothing about authentication or failure behavior.

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

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

The description is a single, direct sentence with no filler and the core output is front-loaded. It is concise, though its brevity contributes to the lack of usage and parameter detail captured in other dimensions.

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

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

Despite having an output schema, an agent cannot safely call this tool: there is no parameter guidance, no usage context, and no behavioral guarantee beyond the word 'suggested.' For a six-parameter tool with no annotations, a one-sentence description is materially incomplete.

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

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

Schema description coverage is 0% and the description maps no parameters to the suggested output. An agent is left to infer the meaning and format of environment, providerConfigKey, principal, ownerKind, purpose, and oauthAppOwner from their names alone.

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

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

The description uses a specific verb ('Build') and names a concrete output: 'a suggested connection_id, tags, and metadata object for a managed connection.' It is clear about the resource and the fact that this is a suggestion, which helps separate it from apply_connection_convention, 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?

There is no guidance on when to use this tool instead of alternatives such as apply_connection_convention, describe_connection_convention, or audit_connection_conventions. The single sentence gives no context about preconditions or intended workflow.

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 behavioral disclosure. It does reveal that the secret key is not returned, which is useful security context, but it does not state whether the operation is read-only, whether 'refresh' changes behavior, or what side effects (if any) occur. This is only minimal disclosure.

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

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

The description is a single sentence that is front-loaded with the primary action and keeps the security-relevant qualifier at the end. There is no filler or redundancy; 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 output schema exists, return format is partially covered, but the description omits when to use the tool, the meaning of the refresh parameter, and behavioral guarantees beyond the secret key. An agent would likely need to inspect sibling tools or rely on trial-and-error to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It loosely maps to the 'environment' parameter ('one configured Nango environment') but says nothing about the 'refresh' parameter, its default, or how it affects resolution. The parameter semantics are largely unexplained.

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

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

The description states a clear verb ('Resolve') and resource ('one configured Nango environment'), and adds a meaningful qualifier ('without returning its secret key') that distinguishes it from a raw list or fetch. However, 'resolve' is somewhat imprecise and could mean validate, fetch, or materialize, so it falls short of a 5.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives like list_environments or get_connection. The singular phrasing implies it is for checking one specific environment, but no exclusions, prerequisites, or sibling comparisons 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only restates the act of creating a token and does not mention side effects, return value, expiration, permissions, or any other behavioral context.

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

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

The single sentence has no wasted words, but it is under-specified rather than skillfully concise. For a tool with four parameters, no annotations, and no output schema, one sentence does not provide an appropriately sized description.

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

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

The description is minimal and there is no output schema or annotations to compensate. Context about how the session token is used, what the response shape is, and how this differs from standard/reconnect session creation is entirely absent.

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

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

Schema description coverage is 0% and the description adds no meaning to any of the four parameters. The agent is left with only param names like environment, allowedIntegrations, tags, and integrationsConfigDefaults, with no explanation of expected values or relationships.

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 verb and resource: 'Create a Nango Connect session token.' It is not a tautology and an agent can tell it creates a session token, but it does not differentiate from sibling tools like create_standard_connect_session or create_reconnect_session.

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 the related session-creation sibling tools. With create_standard_connect_session and create_reconnect_session nearby, this omission leaves the agent to guess which variant is 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?

With no annotations provided, the description bears the full burden of describing behavior, but it only states that an integration is created. It does not mention authentication requirements, idempotency, validation, side effects, or what happens on success or failure. This is minimal behavioral disclosure 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 sentence with no filler or redundant language. It front-loads the primary action and includes a distinguishing detail about the payload convention. 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 two required parameters, a nested arbitrary-shape payload, no output schema, and no annotations, the description is too thin. It fails to explain valid environment values, the expected Nango payload contract, return behavior, or how to verify success. More context is needed for the agent to invoke this tool correctly in practice.

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

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

Schema description coverage is 0%, so the description must compensate. It hints that payload should follow the 'Nango API payload shape,' which adds some meaning, but it does not explain the environment parameter or the payload structure beyond an external reference. This leaves the agent with insufficient information to construct valid arguments confidently.

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 a Nango integration.' This clearly distinguishes it from siblings like update_integration, delete_integration, list_integrations, and get_integration. Adding 'using the Nango API payload shape' also helps differentiate it from other create_* tools and ties it to the Nango domain.

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

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

There is no guidance on when to use this tool versus alternatives such as update_integration or delete_integration. No conditions, prerequisites, or exclusions are mentioned, leaving the agent to infer the appropriate create path from the tool name alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It identifies the operation but does not disclose side effects, whether credentials are invalidated, what a reconnect session actually returns, or any required preconditions. An agent cannot predict the outcome of invoking this 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 a single front-loaded sentence with no filler or redundancy. It is efficiently structured, though its brevity leaves behavioral and usage gaps that are penalized in other dimensions.

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 are no annotations, no output schema, and no parameter descriptions, the description needs to provide substantially more context. It tells the agent what the tool does at a high level but not what a reconnect session is, how it is used afterward, what the response contains, or how it differs operationally from sibling session tools.

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

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

Schema description coverage is 0% and the description provides no additional meaning for environment, connectionId, or providerConfigKey. The parameter names are somewhat self-explanatory, but no formats, defaults, constraints, or relationships are described, and the description does not compensate for the missing schema documentation.

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 ('Create') and resource ('Nango reconnect session'), with the qualifier 'for an existing connection.' This clearly distinguishes it from sibling tools like create_connect_session or create_standard_connect_session, whose purpose is creating new sessions.

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 no explicit when-to-use or when-not-to-use guidance, nor does it name alternatives. 'For an existing connection' implies a distinction from new-connection flows, but the agent is not told when to prefer reconnect over create_connect_session or refresh_connection_credentials.

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 a session is created and a contract is returned, but does not explain side effects, authentication requirements, error behavior, or what the 'post-auth finalization contract' actually entails. For a creation tool this is insufficient.

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

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

The description is a single sentence with no filler, and the action is front-loaded. However, the phrase 'post-auth finalization contract' is jargon that is not explained, and the extreme brevity sacrifices essential detail, making it concise but not optimally clear.

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 10 parameters, no annotations, and no output schema, the description must compensate heavily but does not. It omits explanations of required parameters, usage context, return contract details, and any preconditions. The tool is severely under-specified for an agent to invoke it correctly.

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

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

Schema description coverage is 0% and the description does not explain any of the 10 parameters, such as environment, providerConfigKey, principal, or purpose. The agent is left entirely to infer parameter meaning from names alone, which is especially problematic for ambiguous fields like ownerKind and integrationsConfigDefaults.

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 ('Create') and resource ('Connect session'), and mentions the return of a 'post-auth finalization contract,' which adds specificity. However, it does not distinguish this tool from sibling tools like create_connect_session or create_reconnect_session, so the agent cannot tell which session creation variant to use.

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

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

There is no guidance on when to use this tool versus alternatives such as create_connect_session or create_reconnect_session. The description gives no context about typical scenarios, prerequisites, or conditions under which this standard connect session is preferred.

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 only states that a deletion occurs, without disclosing whether the deletion is permanent, requires special permissions, or cascades to related provider resources.

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, front-loaded, and free of filler. However, it is arguably under-sized given the destructive nature of the operation and the lack of annotations.

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

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

For a destructive tool with no annotations and no output schema, the description is too sparse. It omits important context such as whether deletion is reversible, what happens to the connection's credentials, and how the three required parameters uniquely identify the connection.

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

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

Schema description coverage is 0%, and the description adds no meaning to environment, connectionId, or providerConfigKey. The agent is left with only the parameter names and cannot infer relationships, formats, or constraints from the 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 uses a specific verb ('Delete') and a clear resource ('one Nango connection'), so the core purpose is unambiguous. It implicitly distinguishes itself from siblings like delete_integration or list_connections, though it does not explicitly reference 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 guidance about when to use this tool versus alternatives such as delete_integration, refresh_connection_credentials, or replace_connection_tags. No exclusions, prerequisites, or selection criteria are mentioned.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but 'Delete a Nango integration' does not mention irreversibility, side effects on existing connections, permissions required, or post-deletion state. It adds no behavioral information beyond what the tool name already conveys.

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

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

The description is a single clear sentence with no filler or redundancy. It is immediately readable and every word contributes to stating the core purpose, making it maximally 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 a destructive tool with two required parameters, no annotations, and no output schema, the description lacks all contextual detail: no side effects, no parameter semantics, no prerequisites, and no return value expectations. An agent cannot confidently construct a correct and safe invocation.

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

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

Schema description coverage is 0%, and the description does not define 'environment' or 'integrationId' beyond their names. No formats, examples, constraints, or relationships between the parameters are given, leaving the agent to guess valid inputs.

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

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

The description clearly states the verb 'Delete' and the resource 'a Nango integration', making the core purpose unambiguous. It is naturally differentiated from sibling tools like create_integration, update_integration, get_integration, and list_integrations by the destructive verb.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no indication of prerequisites, such as whether the integration must exist first, or how this relates to delete_connection, which handles a different resource. Usage context is only implied by the verb.

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 says 'explain', which implies a read-only operation, but it does not state whether this is purely informational, whether it performs any side effects, or what the return format is. The lack of behavioral detail is a significant gap for a tool that generates output.

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, but it is under-specified rather than concise. It omits critical information about the tool's purpose and behavior, so brevity here does not equate to efficiency—it is a deficiency.

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

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

Despite having an output schema, the description does not explain what the tool returns or how the output relates to the 'helpers' it describes. It does not provide enough context for an agent to know what kind of response to expect or how to integrate this tool into a workflow, especially given the rich sibling toolset.

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 does not need to explain parameters, and no ambiguity exists 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 states a verb ('Explain') and a resource ('Nango MCP connection convention helpers'), but the resource is vague—'helpers' is ambiguous and does not clarify what these are. It does not distinguish this from sibling tools like build_connection_convention or apply_connection_convention, leaving an agent uncertain about the exact scope of the explanation.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of context, prerequisites, or exclusions. An agent cannot infer when 'describing' is more appropriate than 'auditing', 'building', or 'applying' conventions.

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 behavioral burden. It does disclose that the tool streams a GET response and creates or targets a protected MCP binary resource, which is useful. However, it omits important behavior such as whether a resource is created or overwritten, how the binary resource is accessed afterward, what errors can occur, and what the return value represents.

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

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

The description is a single, direct sentence with no filler or repetition. It front-loads the core behavior and the destination, so it earns its place despite being short.

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, no-annotation, no-output-schema tool in a crowded sibling set, this description is too thin. An agent cannot determine required connection/auth context, how to set the file name, how query/headers interact with the GET request, or what the resulting MCP resource looks like.

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

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

The schema has 8 parameters and 0% description coverage, and the tool description does not explain environment, providerConfigKey, connectionId, path, query, headers, suggestedName, or baseUrlOverride. The phrase 'provider GET response' only weakly hints at providerConfigKey and path, leaving nearly all parameter semantics undocumented.

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

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

The description names a specific action ('Stream a provider GET response') and a specific target ('protected MCP binary resource'), so an agent can tell this is a download-style operation. It does not explicitly contrast it with sibling tools like proxy_request, but the 'into a protected MCP binary resource' phrase gives enough differentiation to avoid immediate confusion.

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 proxy_request or query_response_artifact. The description states what it does but not the conditions that make it the right choice, so an agent gets no help with tool selection from the sibling set.

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 the behavioral burden. It discloses one useful trait: credential-like response fields are redacted. However, it does not explain how includeCredentials affects that behavior, what response shape is returned, or whether there are side effects, leaving significant behavioral context unstated.

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, and the most important caveat (redaction) is placed prominently. 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?

There is no output schema and no annotations, so the description needs to be more informative to be complete. It leaves key call semantics undefined: parameter meanings, default vs. includeCredentials true behavior, response format, and potential errors. The redaction note is useful but not sufficient for confident invocation.

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

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

Schema description coverage is 0% and the description adds no parameter-level meaning. It does not explain environment, connectionId, providerConfigKey, or the implications of includeCredentials. The parameter names are somewhat self-explanatory, but the description fails to compensate for the missing schema descriptions.

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

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

The description names a specific verb and resource: 'Get a Nango connection.' It clearly identifies a single-connection fetch operation. It does not explicitly contrast with sibling tools like list_connections or get_connection_context, so it falls short of full 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 no guidance about when to invoke this tool versus alternatives such as list_connections or get_connection_context. It provides neither prerequisites, exclusions, nor routing conditions. Any inference about usage must come from the tool name and sibling names rather than the description.

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

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

With no annotations, the description carries the behavioral disclosure burden. It usefully discloses that the result is compact and redacted, implying a summarized, sanitized view. However, it does not state side effects, authentication requirements, or behavior when the connection is missing or invalid.

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 the main verb and key qualifiers front-loaded. It is concise without being tautological, though it sacrifices some helpful 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?

The output schema exists, so return structure is covered, but the description is too sparse given four parameters, zero annotation coverage, and a crowded sibling set. An agent lacks enough context to know when to prefer this over get_connection or how to interpret the parameters.

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

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

Schema description coverage is 0%, and the description names none of the four parameters, including includeRawProviderTemplate, which is not self-explanatory. The description adds no meaning beyond the parameter names already visible 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 uses a specific verb ('Return') and names a distinct resource ('context view for one connection'), adding 'compact, redacted' to signal the output shape. It is clear in general, though it does not explicitly distinguish itself from the closely related sibling get_connection.

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 the many connection-related siblings, especially get_connection. No exclusions, prerequisites, or alternative conditions are mentioned, leaving the agent to guess which lookup is 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 redaction statement is a useful behavioral disclosure, especially since no annotations are present. However, it does not clarify how the includeCredentials parameter interacts with this redaction, leaving ambiguity about whether credentials are ever returned. No annotation contradiction exists.

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

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

Two short sentences, front-loaded with the core purpose and followed by a key security-relevant caveat. 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 has three parameters and no output schema or annotations, yet the description leaves important context unexplained: what values environment accepts, what integrationId refers to precisely, and what includeCredentials actually changes. The redaction note is helpful but not enough for complete invocation confidence.

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 needed to explain the parameters but does not mention environment, integrationId, or includeCredentials semantics. The redaction note relates to output behavior, not to what the parameters mean or how to supply them.

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 ('Get one Nango integration') and the resource, so an agent knows this is a single-item retrieval rather than a listing. It does not explicitly contrast itself with siblings like list_integrations, but the singular 'one' provides enough separation.

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 phrasing implies the tool is for fetching a single integration by ID, which gives some usage context. However, it does not provide explicit when-to-use guidance, exclusions, or references to alternatives such as list_integrations.

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 present, so the description carries the full behavioral burden. It implies a mutation ('import/create') but does not disclose side effects, idempotency, overwrite behavior, authentication needs, or what happens if the connection already exists. The Nango payload mention is an input hint, not behavioral context.

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

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

The description is one short sentence with no filler and the action is front-loaded. It earns conciseness credit, though the terseness contributes to the lack of substantive guidance.

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

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

For a mutation tool with no annotations, no output schema, and two required params including a nested object, this description is far from complete. An agent cannot reliably construct the payload, interpret the environment value, or predict the outcome. More context about the Nango API shape and behavior is essential.

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

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

Schema description coverage is 0% and both required parameters are otherwise undocumented. The phrase 'Nango API payload shape' gives a weak hint about the payload parameter, but environment is completely unexplained and the payload's required fields are not specified. The description only minimally compensates for the missing schema detail.

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

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

The description names a specific action ('Import/create') and resource ('a connection'), and adds a meaningful qualifier ('using the Nango API payload shape'). It is clear about the basic operation, though it does not explain the distinction between 'import' and 'create' or differentiate it from connection-related 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?

There is no guidance on when to use this tool versus alternatives such as create_connect_session, get_connection, or delete_connection. No prerequisites, exclusions, or context are provided, so an agent has no routing information.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only listing but does not disclose required environment context, pagination, filtering semantics, authentication, or what the response contains. The reference to 'documented query filters' is not self-contained and adds no concrete behavioral detail.

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

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

The description is appropriately brief and front-loaded with the action and resource. However, it is under-specified rather than efficiently complete, and the vague reference to external documentation wastes the opportunity to add structured, valuable guidance.

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

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

Given 7 parameters, 0% schema coverage, no output schema, and no annotations, the description is far from complete. It communicates the basic purpose and that filters exist, but an agent cannot correctly invoke the tool without external Nango documentation. Essential details about environment, parameter semantics, and return shape are absent.

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

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

Schema description coverage is 0% and the description does not explain any of the 7 parameters. Saying 'query filters' generically does not clarify what search, connectionId, integrationId, endUserId, or endUserOrganizationId mean or how they interact. The description must compensate for the empty schema descriptions but fails to do so.

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 verb ('List') and resource ('Nango connections'), and mentions query filtering, which distinguishes it from broader tools like list_environments. However, it relies on vague external documentation ('Nango's documented query filters') and does not explicitly contrast it with singular get_connection.

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 get_connection or list_integrations. No conditions, exclusions, or preferred use cases are provided, so the agent must infer usage from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It usefully reveals that secret material is not returned, which is a safety-relevant trait, but it does not state whether the operation is read-only, how the refresh parameter behaves, or any caching or rate-limit implications.

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 action and resource are front-loaded, and every word adds 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?

The tool is simple and has an output schema, so return-value details are presumably covered elsewhere. However, the meaning of the only parameter is left undocumented and there are no annotations to cover safety or behavioral context, leaving the definition minimally viable but not complete.

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

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

The only parameter, 'refresh', has zero schema description coverage and the tool description never mentions it. The agent cannot determine what refresh does, whether it forces a reload, or when it should be set to true, so the description fails to compensate for the missing schema documentation.

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

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

The description specifies the verb 'List' and the resource 'configured Nango environments', and adds the meaningful qualifier 'without returning secret material'. This clearly distinguishes it from sibling tools like list_integrations and list_connections.

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 check_environment. No exclusions, prerequisites, or alternative tool mentions are provided, so the agent must infer usage from the tool name and context.

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 states the listing action but omits any mention of the refreshSecret parameter's behavior, whether the operation is read-only, or what the return payload looks like. The refreshSecret flag could imply side effects or extra behavior that an agent would not anticipate.

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, front-loaded sentence with no filler. Every word earns its place and the core purpose is immediately visible.

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 and no annotations, this description is too thin. It does not mention return structure, pagination, the meaning or effect of refreshSecret, or how this relates to sibling tools. An agent has enough to guess the basic purpose but not enough to call the tool with full confidence.

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

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

Schema description coverage is 0%, so the description must compensate. It indirectly adds meaning to 'environment' by saying integrations are configured in one Nango environment, but it says nothing about accepted values or format, and it completely omits the refreshSecret parameter and its semantics.

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

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

The description names a specific verb ('List'), resource ('integrations'), and scope ('configured in one Nango environment'). This clearly differentiates the tool from siblings like list_connections and list_environments, and from get_integration which targets a single integration.

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 offers no guidance on when to choose this tool over alternatives such as get_integration, list_connections, or list_environments. No conditions, prerequisites, or exclusions are mentioned, leaving the agent to infer usage solely from the word 'List'.

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, but it only mentions token secrecy. It does not disclose that this can forward arbitrary HTTP calls with potentially mutating effects, nor does it mention pagination, response handling, or rate limits.

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 efficient sentence with the main function front-loaded and no filler. However, its brevity comes at the cost of omitting important operational details.

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

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

For a tool with 16 parameters, zero schema descriptions, and no annotations, a single sentence is far from complete. There is no guidance on required identifiers, request composition, pagination, response behavior, or error 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 0%, and the description explains none of the 16 parameters. Required fields like environment, providerConfigKey, connectionId, method, and path are left entirely to the bare schema titles, so an agent cannot infer their meaning or 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 states a specific action ('Call a provider API through the Nango Proxy') and a distinctive security property ('without exposing provider tokens'), making the primary function clear. It does not explicitly contrast with siblings like stage_proxy_request_body, but the core purpose is still recognizable.

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 choose this tool over related siblings such as stage_proxy_request_body or query_response_artifact. The token-hiding qualifier hints at a security benefit but does not help an agent decide between alternatives.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only hints at 'bounded' behavior and 'strict camelCase' controls, but does not explicitly state that this is read-only, whether pagination is used, how artifacts are returned, or what side effects (if any) exist. This is too sparse for a tool with ten parameters.

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

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

The description is a single sentence with no filler, and the main verb and resource are front-loaded. However, the phrase 'bounded, strict camelCase controls' is jargon-heavy and could be clearer. It is concise but not optimally transparent.

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 tool has high complexity: ten parameters, no parameter descriptions, no annotations, and a specialized name. The description does not explain how to construct valid filters, what objectMode entries means, how responsePath interacts with the artifact, or when to set describe. An agent cannot reliably invoke this tool from the provided information.

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

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

Schema description coverage is 0%, so the description must compensate for ten undocumented parameters. It does not describe artifactId, environment, cursor, fields, filters, describe, pageSize, objectMode, textSearch, or responsePath. The phrase 'strict camelCase controls' may hint at output naming conventions, but it does not map to any specific parameter 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 states a specific verb and resource: 'Query a stored provider response'. This distinguishes it from most sibling tools, which are about connections, integrations, or proxying requests. However, it does not explicitly differentiate itself from closely related query-like tools, and the phrase 'bounded, strict camelCase controls' is 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?

There is no guidance about when to use this tool versus alternatives such as proxy_request, download_provider_file, or get_connection_context. No context, prerequisites, or exclusions are provided, so an agent has to infer the appropriate use case from the name alone.

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

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

With no annotations, the description carries the full burden and does disclose the mutating nature ('Force') and the restricted output ('non-secret'), which is useful. However, it says nothing about side effects such as token invalidation, required permissions, rate limits, or failure behavior, leaving meaningful behavioral uncertainty.

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 with no filler, front-loaded with the action verb. Every word contributes meaning 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?

An output schema exists, so return-value details are partially covered, but the description omits parameter semantics and all usage conditions. For a mutating tool with no annotations, this is too sparse to safely invoke, especially given 27 sibling tools.

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

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

The schema description coverage is 0% and the description provides no explanation of the three required parameters (environment, connectionId, providerConfigKey). An agent must guess their meanings purely from parameter names, which is inadequate for reliable invocation.

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

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

The description uses a specific verb phrase 'Force an OAuth refresh' and identifies the precise resource (connection credentials). It further distinguishes the tool from siblings by specifying the narrowed output ('non-secret credential summary'), which clearly separates it from read-only tools like get_connection.

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 alternatives. The description states what it does but not when a refresh is appropriate, what prerequisites exist, or how this differs from related tools like get_connection or create_reconnect_session.

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 clearly reveals that the tool is destructive or overwriting by emphasizing 'complete tag set' and instructing the agent to 'Fetch and merge first.' This is important non-obvious behavior beyond what the input schema shows.

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 wasted words. It front-loads the core operation first and then adds essential safety guidance, 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?

For a simple replace-operation tool, the description conveys the main behavior and a critical caveat. However, it omits return value details, any failure modes, and parameter semantics for three of the four required arguments, which matters more because there is no output schema and no 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 0%, and the description does not compensate by explaining the meaning or accepted values of environment, connectionId, providerConfigKey, or the tags object structure. The only semantic hint is 'tag set' linking to the tags parameter. An agent must infer most parameter meaning from names alone.

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

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

The description states a specific verb ('Replace') and a clear resource ('a connection's complete tag set'), and explicitly distinguishes full replacement from incremental changes by advising 'Fetch and merge first when changing one tag.' This clearly differentiates it from sibling tools like update_connection_metadata.

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

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

The description gives clear operational context by warning that changing one tag requires fetching and merging first, implying this tool is for wholesale replacement. It does not explicitly name alternative tools or state 'do not use for single-tag edits,' but the guidance is sufficient for an agent to select the correct 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 provided, the description carries the behavioral burden. 'Search' implies a read-only lookup and 'before creating an integration' reinforces that it is not a mutation. However, it does not disclose behavior around raw templates, environment requirements, or what happens when no matches are found.

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 with no filler. The main action and workflow position are front-loaded, making it easy to scan and immediately actionable.

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 output schema may cover return values, but the tool has four input parameters, no annotations, and no parameter descriptions. The description lacks enough detail about required inputs and template filtering behavior for an agent to invoke it with confidence; `includeRawTemplates` is particularly opaque.

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

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

Schema description coverage is 0% and the description does not explain the four parameters. 'Search' hints that `query` is the search term, but `environment`, `limit`, and especially `includeRawTemplates` are left undefined. The description needed to compensate for missing schema descriptions and does not.

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

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

The description clearly states a specific action and resource: 'Search Nango provider templates before creating an integration.' It identifies the tool's role as a pre-creation lookup and separates it from integration/connection management siblings. It does not explicitly contrast it with an alternative tool, but the resource and workflow are clear.

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 temporal guidance: use this 'before creating an integration,' which tells the agent when in the workflow the tool belongs. It does not mention exclusions or alternative tools, but the pre-creation context is strong enough for a simple search 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, the description carries the burden of behavioral disclosure. It adds useful behavior by saying the body is 'immutable' and that only a 'bounded descriptor' is returned, implying the full body is not echoed. It does not mention environment requirements, storage lifetime, or side effects, but this is a reasonable baseline for a staging 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 a single tightly-worded sentence with no redundancy. It front-loads the core action and return type, and every phrase earns its place.

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

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

The presence of an output schema reduces the need to explain the returned descriptor. Still, with no annotations and no schema descriptions, the description leaves the meaning of 'environment' and the relationship to proxy_request implicit. For a simple two-parameter staging tool, this is adequate but not thorough.

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

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

Schema description coverage is 0% and the body parameter has no type in the schema, so the description's phrase 'outbound JSON body' adds some meaning. However, the environment parameter is completely unexplained, and no constraints on body size, format, or environment values are provided. At 0% schema coverage, the description should compensate more than it does.

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 ('Stage') and clearly identifies the resource ('immutable outbound JSON body') and the return value ('bounded descriptor'). It conveys that this tool does not actually send a request, which separates it from sibling proxy_request. However, it does not explicitly name or contrast sibling tools, so differentiation is implicit rather than explicit.

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

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

No guidance is given about when to use this tool versus alternatives such as proxy_request or direct body passing. The description does not explain that this should precede a proxy request, nor does it state any conditions for using it. Only the tool name hints at the staging workflow.

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 full responsibility for behavioral disclosure. It does disclose a meaningful behavior—verify by read-back—but otherwise gives only the vague word 'safely'. It does not explain side effects on existing identity fields, permission requirements, or what happens when optional identity fields are omitted.

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 sentence with no filler. 'Safely update' is front-loaded and the read-back verification is placed at the end, giving the agent the core purpose immediately.

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?

Although an output schema exists, the description lacks enough context for correct invocation: no guidance on when to use it, what the optional identity fields mean, or what side effects the update has. For a mutation tool with no annotations and six parameters, this is a significant completeness 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 0%, and the description does not compensate by explaining how id, email, displayName, environment, connectionId, or providerConfigKey relate to the update operation. It implies identity fields exist but leaves their semantics to inference, which is insufficient given the complete lack of parameter 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 clearly states a specific verb ('update') and resource ('native Nango end-user identity'), and adds a distinctive behavioral element ('verify it by read-back'). This differentiates it from sibling tools like update_connection_metadata or replace_connection_tags.

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 update_connection_metadata or import_connection. It does not state prerequisites, exclusions, or conditions that would lead an agent to select this tool over others.

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 behavior disclosure. It does communicate the merge-vs-replace mode and explicitly warns against storing credentials. But it does not disclose consequences of 'replace' (e.g., whether it wipes existing metadata), permissions, or side effects, which are important 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 two short sentences with no filler. The core behavior is front-loaded, and the credential warning earns its place as a safety note.

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 five parameters, a nested object, no annotations, and no output schema, the description is too sparse. It lacks clarification of the identifiers, the effect of replace mode on existing data, and any return or error behavior, leaving significant gaps for an agent trying to call it correctly.

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

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

Schema description coverage is 0%, so the description must clarify the parameters. It adds meaning to 'metadata' and 'mode,' but environment, connectionId, and providerConfigKey remain explained only by their names. This is insufficient compensation for five parameters with no schema-level 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 clearly states the action ('Merge or replace') and the resource ('structured connection metadata'). This distinguishes it from sibling tools like update_connection_end_user and replace_connection_tags, which operate on different connection aspects.

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 a relevant boundary with 'Do not store credentials here,' telling the agent what not to put in this tool. However, it does not explicitly state when to choose this tool over alternatives such as get_connection_context or replace_connection_tags, leaving that inference to the 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 present, so the description carries the full behavioral burden. 'Patch' implies a mutation, but it does not disclose whether the update merges or replaces fields, what happens to existing connection data, whether reconnection is triggered, or what side effects may occur. This is slightly better than nothing but still very thin.

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 in length, but it is too sparse to be considered well-structured. It does communicate the core action quickly, but it lacks the meaningful detail that would justify its minimalism.

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 tool has five parameters, three required, a nested object, a boolean with default, an array/null union, no annotations, and no output schema. A single sentence without parameter semantics, usage context, or behavioral effects is not remotely sufficient for an agent to invoke this correctly.

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

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

Schema description coverage is 0%, and the description provides zero parameter-level information. None of the five parameters (environment, integrationId, fields, reconnectConnectionIds, autoReconnectSingleMatchingConnection) are explained, and the free-form 'fields' object is completely uninterpretable from the description alone.

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

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

The description uses a specific verb ('Patch') with a clear resource ('a Nango integration'), and the PATCH semantics distinguish it from create/delete/get sibling tools. It is not a full tautology, though it does not explain what an integration is or what aspects can be updated.

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 create_integration, delete_integration, or update_connection_metadata. No context, prerequisites, or exclusions are provided; the agent must infer usage entirely from the tool name and schema.

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