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

Annotations already convey mutation (readOnlyHint=false) and non-idempotence; the description's 'Create' adds no further behavioral context such as side effects, duplicate handling, permission requirements, or response behavior. With annotations present the bar is lower, but the description still contributes essentially no beyond-annotation 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 short sentence with no filler, and the core action and target are front-loaded. However, it is so terse that it provides little information beyond the tool name, so while efficient, it is not exemplary 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 create operation with four simple parameters and full schema coverage, the combination is just sufficient to construct a valid call. It is not fully complete because there is no output schema, no indication of what the successful response contains, and the relationship to project creation is left implicit.

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 each parameter has its own description, so the schema fully carries the semantic burden. The tool description adds nothing about parameters, 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 names a specific action ('Create') on a specific resource ('environment') and the system ('Infisical'), which is enough to distinguish it from sibling tools like create-project, create-secret, and create-folder at a glance. It does not explain what an environment is or how it relates to those other resources, so it stops short of full clarity.

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

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

No guidance is provided on when to use this tool, whether an existing project is a prerequisite, or how it compares to alternatives like create-project or create-folder. The agent must infer context solely from the required projectId parameter.

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

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

The description adds no behavioral context beyond what annotations already declare. Annotations indicate a non-read-only, non-idempotent, non-destructive operation, but the description does not mention duplicate handling, permission requirements, path behavior, or effects on existing folders.

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 no filler or redundancy. It front-loads the core action and resource clearly.

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 create operation with complete schema coverage, the description plus annotations are minimally sufficient. However, it does not explain how projectId/environment are obtained, what happens on duplicate names, or what the successful response contains, so it is adequate but not rich.

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 itself adds no parameter-level meaning beyond saying a folder is created, but the schema already documents name, path, projectId, description, and environment adequately.

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

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

The description clearly states a specific verb and resource: 'Create a new folder'. It also names the product context ('in Infisical') and distinguishes this tool from sibling tools like create-secret, create-project, and create-environment by targeting a different resource type.

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, when not to use it, or what prerequisites are needed. The distinction from sibling tools relies entirely on the resource name rather than explicit routing or 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?

Annotations already indicate this is a write operation (readOnlyHint false), non-idempotent, and non-destructive. The description adds no additional behavioral details such as permissions required, reversibility, or potential side effects. It does not contradict annotations but also does not enrich them.

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

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

The description is a single, concise sentence that front-loads the action. It contains no unnecessary words and is efficiently structured.

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

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

The tool is straightforward, and the schema covers parameters. However, the description omits any mention of return values, potential errors, or additional context like whether the project name must be unique. Given the absence of an output schema and the tool's moderate complexity, a slightly richer description would be more complete, but it is minimally adequate.

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

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

The schema covers 100% of parameters with descriptions, so the description is not responsible for parameter meaning. The description adds no extra parameter semantics beyond what the schema already provides, which meets the baseline for full 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 ('Create') and the resource ('a new project') within the system ('Infisical'). It is specific and distinguishes from sibling tools like create-secret or create-environment, which target different resource types.

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

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

The description provides no guidance on when to use this tool versus alternatives or any exclusions. While the tool name and sibling context make the purpose obvious, the description itself offers no usage context, such as prerequisites or conditions for selection.

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

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

Annotations already indicate readOnlyHint=false, destructiveHint=false, and idempotentHint=false, so the agent knows this is a non-read, non-idempotent mutation. The description adds a minimal statement that it creates a secret, which aligns with the annotations. It doesn't go beyond what annotations provide—no mention of side effects, permissions, or error behavior. Since annotations cover the mutation type, a 3 is appropriate, but the description carries little extra weight.

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 clearly states the tool's purpose. It is not verbose and gets straight to the point, though it lacks any additional context that might be useful. It is appropriately sized, but not maximally informative—still earns a 4 for efficiency.

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 is a create operation with no output schema and moderate complexity (5 params), the description is minimal but functionally sufficient. It tells the agent what the tool does, but does not cover edge cases like secretPath defaults or the effect of omitting secretValue. Annotations cover the mutation, but the description does not elaborate on behavior such as whether it overwrites existing secrets. A 3 indicates it is adequate but with 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 schema description coverage is 100%, meaning all five parameters are already described in the input schema. The description itself does not add any additional meaning about parameters beyond what the schema provides, so no extra value is added. Baseline 3 is appropriate given full 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 'Create a new secret in Infisical' clearly identifies the verb (create) and the resource (secret), and the context (Infisical). It is specific enough to distinguish it from create-project or create-environment, though it does not differentiate from update-secret by name, but the verb 'create' vs 'update' is sufficient.

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 (creating secrets) and is self-evident given the tool name. However, it does not provide any guidance on when to use this tool versus alternatives like update-secret or delete-secret, nor does it mention any prerequisites or constraints.

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

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

The annotations already declare destructiveHint=true and idempotentHint=true, so the agent knows it is destructive. The description adds no extra behavioral context, such as what happens to associated data or whether the deletion is permanent. Given the annotations cover the destructive nature, the description doesn't contradict them, but it also fails to add meaningful value beyond what annotations provide.

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

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

The description is a single short sentence (six words) that is concise and front-loads the core action. It has zero fluff and clearly states the tool's purpose in minimal words. This is appropriately concise for a simple delete operation.

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

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

For a destructive tool with no output schema and no additional annotations explaining side effects, the description is somewhat thin. It covers the basic action and parameters are fully described in the schema, but it does not warn about irreversible consequences or provide usage examples. Given the tool's destructive nature and low complexity, a bit more context (e.g., confirmation of permanent deletion) would improve completeness.

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

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

The schema description coverage is 100%, meaning all parameters are described in the schema. The description itself does not elaborate on parameter semantics beyond what the schema states. Since the schema already provides clear descriptions for each parameter, including defaults (e.g., secretPath defaults to /), the description adds no additional value, but the bar is met with the schema.

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

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

The description clearly states the action ('Delete') and the resource ('a secret in Infisical'), which is specific enough to understand the tool's core purpose. However, it does not distinguish itself from sibling tools like 'create-secret' or 'update-secret' beyond the verb, which is already evident from the name. Still, it is clear and not a tautology.

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. It does not mention any prerequisites, such as requiring appropriate permissions, or warn about destructive consequences like irreversible data loss. The presence of sibling tools like 'create-secret' and 'update-secret' implies a shared context but no explicit routing is 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds no behavioral context beyond the name, such as secret import resolution, reference expansion, default path behavior, or not-found behavior, contributing nothing beyond what annotations already provide.

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

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

The description is a single front-loaded sentence with no filler, communicating the core action efficiently. It is concise rather than verbose, though it leans toward under-specification rather than informative 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?

With a rich schema (100% coverage) and annotations covering safety, the description doesn't need to restate parameters. However, it omits guidance on return values and alternative selection, and it doesn't mention the default secretPath or import/reference behaviors that affect results. Adequate for a simple read tool but with 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?

Schema description coverage is 100%, so all six parameters have descriptions in the input schema, establishing the baseline of 3. The tool description itself adds no parameter-level meaning beyond what the schema already provides.

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

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

The description states a specific verb ('Get') and resource ('a secret in Infisical'), clearly identifying a read operation for a single secret. However, it doesn't explicitly distinguish from list-secrets or mention scoping parameters like project/environment/path, so it stops short of full sibling differentiation.

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

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

The description gives no guidance on when to use get-secret versus sibling tools such as list-secrets, create-secret, or update-secret. There is no mention of alternatives, exclusions, or use-case context, leaving the agent to infer 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?

The description adds no behavioral context beyond the annotations: it merely restates the tool's purpose and does not mention side effects such as invitation emails, permission requirements, idempotency behavior, or response outcomes. Since annotations already indicate non-readonly, non-destructive, and non-idempotent behavior, the description provides no additional transparency.

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 text and the key operation is front-loaded. It is appropriately minimal for a simple invitation tool, though it is minimal enough that it leaves behavioral and usage guidance to other fields.

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 thoroughly documents all parameters, and the annotations cover the core action. However, with no output schema, no permission context, and no mention of related alternative tools, the description is adequate but leaves some operational context to inference.

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 provides descriptions for all four parameters, including the either/or requirement for usernames and emails and the default roleSlugs default. Since schema coverage is 100%, the description itself does not need to add parameter detail and does not materially add meaning beyond the schema.

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

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

The description states a specific action (invite), a specific resource (members) and the target system (Infisical), so an agent can immediately identify what the tool does. It also distinguishes itself from all siblings, which cover secrets, projects, folders, and environments, none of which handle member invitations.

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

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

The description does not explicitly state when to use this tool versus alternatives or when not to use it. The intended use case is implied by the phrase 'Invite members to a project,' and there is no closely related sibling tool, but no direct guidance is 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?

Annotations already declare read-only and idempotent behavior models. The description adds that results are scoped to what the calling identity has access tochers, which is informative, and clarifies the all parameter semantics. No destructive side effects or other behavioral caveats are disclosed, but the annotation bar is covered.

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. The first states the core action clearly; the second offers a usage hint. Slight redundancy with the schema's parameter description, but it does not waste words.

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 operation with one enum parameter, the schema plus description cover the invocation logic. The access-scope note is an important contextual detail. No output schema exists, but a list operation's return shape is reasonably predictable; overall the description is 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 already fully describes the type parameter, its enum values, and the default of all. The description repeats this with a user-intent example ('If the user asks to list all projects...') but does not add substantive new meaning beyond the schema.

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

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

The description uses a specific verb ('List') with a clear resource ('all projects in Infisical') and scopes the action to 'the machine identity has access to', which clearly identifies the operation. This distinguishes it from sibling tools such as list-secrets or create-project 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 states the tool is for listing projects and gives a specific instruction for handling 'all projects' via the type parameter. However, it does not provide when-to-use vs. alternatives or exclusions, though the tool name and sibling context make this mostly inferable.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds no behavioral context beyond the schema (e.g., no mention of pagination, default paths, or expansion behavior), but with annotations covering the key traits, a 3 is appropriate.

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 action and resource. It is efficient and free of filler, though it could add a bit more scoping detail without becoming verbose.

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

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

For a read-only list operation with full schema coverage and safety annotations, the description is mostly adequate. However, it lacks context about return format, pagination, or how includeImports/expandSecretReferences affect results, which an agent might need to interpret the output 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 100%, so the schema already documents all 5 parameters. The description adds no additional meaning beyond what the schema provides, 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 states a clear verb ('List') and resource ('secrets') with scoping context ('in a given Infisical project and environment'). It distinguishes from mutation siblings like create-secret/delete-secret/update-secret, though it doesn't explicitly differentiate from get-secret (which is a sibling that also reads secrets).

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 for listing secrets in a project/environment, and the readOnlyHint annotation signals safe read-only usage. However, it does not explicitly state when to prefer this over get-secret or mention any exclusions or alternatives.

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

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

The description adds no behavioral detail beyond the word 'update'. The annotations already indicate destructiveHint=true, readOnlyHint=false, and idempotentHint=true, so the description itself does not disclose side effects, overwrite behavior, or requirements. It neither enriches nor contradicts the annotations.

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

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

The description is a single, compact sentence with no waste. The core action and object are front-loaded, so an agent can grasp the tool's purpose in under a second.

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

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

Given that this is a destructive, parameter-rich mutation with no output schema, the description is too thin. It should mention that the secret must already exist, that values/names are overwritten, and any preconditions around renaming or environment/path context.

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

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

Schema coverage is 100%, and the description contributes no additional parameter-level insight. The baseline of 3 applies; the schema already explains what each parameter is for.

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') and a resource ('a secret in Infisical'). This clearly differentiates it from siblings like create-secret, delete-secret, and get-secret based on the operation alone.

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

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

There is no guidance about when to use this tool versus the other secret-related tools. It implies updating an existing secret, but it doesn't state prerequisites or when a user should choose this over create-secret or get-secret.

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