crowdin

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

Annotation Contradiction: annotations declare destructiveHint=true while the description explicitly calls the operation 'additive'. 'Additive' implies no existing data is destroyed, which directly conflicts with the destructive hint. No other behavioral traits are disclosed.

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

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

A single front-loaded sentence states the action and the API endpoint, with a clarifying parenthetical. No redundant content.

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

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

For a mutating tool with no output schema, the description leaves gaps: it does not explain return behavior, idempotency, or prerequisites such as file existence. The annotation conflict further reduces the agent's ability to predict side effects.

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

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

Schema description coverage is 100%, so all seven parameters are documented in the schema. The description adds the API path confirming projectId is a path parameter, but does not need to explain parameter semantics further.

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

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

Description uses a specific verb and resource: 'Adds a source string to a file in a Crowdin project', and reinforces it with the exact API endpoint. This distinguishes it cleanly from sibling tools like crowdin_add_translation.

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

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

The description clearly implies when to use it: when a new source string must be inserted into an existing file. It does not explicitly name alternatives or exclusions, so it stops short of 5, but the context is unambiguous.

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

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

The description explicitly calls the operation 'additive', implying non-destructive behavior, while the annotations declare destructiveHint=true. This is a direct contradiction between the description and the structured metadata, leaving the agent with conflicting safety signals.

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

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

The description is a single concise sentence with the core operation and endpoint. The parenthetical 'additive' is short but informative, though it contributes to the contradiction with the annotation.

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 five parameters, a destructiveHint=true annotation, and no output schema, the description lacks return behavior, duplicate/overwrite semantics, and permission requirements. It covers the basic operation but leaves important side-effect questions unanswered.

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

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

The input schema already describes all five parameters with 100% coverage, so the description does not need to repeat them. It adds only the endpoint context for projectId and no deeper parameter-level 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 verb ('Adds'), names the resource ('translation for a source string in a target language'), and includes the exact API endpoint. This clearly distinguishes it from sibling tools like crowdin_add_string and the list/get tools.

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

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

No guidance is given about when to use this tool versus alternatives, nor are any prerequisites or exclusions mentioned. The agent must infer the intended use from the name and the phrase 'for a source string'.

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, so the safety profile is covered. The description adds the endpoint and clarifies the output is per-target-language percentages, but does not disclose pagination behavior, response shape, or potential empty/failed states beyond what the schema already implies through limit/offset.

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

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

The description is a single focused sentence that states the tool's purpose immediately, followed by the concrete API endpoint. There is no filler or repetition of schema details.

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

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

For a simple read-only list-like endpoint with full schema coverage and a readOnlyHint annotation, the description provides the core context: target language, translation vs. approval, and project scope. It does not describe the response format, but given the absence of an output schema and the low complexity, this is a minor gap.

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

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

Schema description coverage is 100%, so every parameter (projectId, limit, offset) is already documented with type, bounds, and purpose. The description adds no extra parameter-level meaning, so the baseline of 3 applies.

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

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

The description names a specific verb and resource: getting per-target-language translation and approval completion percentages for a project. It clearly differentiates this from the sibling tools, which cover adding strings/translations, listing files/branches, and getting project 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 states what the tool returns but gives no explicit guidance on when to prefer it over alternatives or when not to use it. The 'headline localization status' phrase implies it is the primary progress view, but no sibling comparison or exclusion 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=true, so the agent knows this is a safe read operation. The description adds useful context by naming the REST endpoint GET /projects/{projectId} and the detail categories included, but it does not cover error behavior or response format, which are minor gaps given the read-only profile.

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 a parenthetical listing the key detail types, followed by the exact API route. Every element earns its place and the main purpose is front-loaded.

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

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

For a one-parameter, read-only tool with full schema coverage, the description conveys enough for correct selection and invocation. It names the resource, inputs, included details, and endpoint; a full output schema is absent, but the description gives a reasonable sense of what the response contains.

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%: projectId is fully described with type, range, requiredness, and provenance ('from crowdin_list_projects'). The description's 'by id' adds no new parameter meaning beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Get a single project's details by id', and explicitly enumerates included content (settings, languages, counts). This clearly distinguishes the single-project tool from the sibling crowdin_list_projects without needing to inspect the schema.

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

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

The description establishes clear context: use this when you already have a projectId and need one project's details rather than a collection. The schema's parameter note 'from crowdin_list_projects' reinforces the workflow, though the description itself does not explicitly name alternatives or state when not to use it.

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, so the safety profile is covered. The description adds the exact API endpoint and the returned fields (id, name, title), which is useful but does not disclose pagination behavior 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?

Two tight sentences with the key purpose front-loaded and the API reference included. Every word earns its place with no redundancy.

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

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

For a simple read-only list operation with full schema coverage and annotations, the description is nearly complete. It identifies the resource, the project scope, the response fields, and the API endpoint; only explicit pagination/usage context is missing.

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

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

Schema description coverage is 100%, so the schema already documents projectId, name, limit, and offset. The description mentions 'id, name, title' as output fields, which is helpful, but it does not add meaning to the parameters themselves.

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 and resource: 'List version branches in a project' and names the returned fields. It does not explicitly differentiate from sibling list tools, but the branch resource is distinct enough.

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

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

The phrase 'in a project' gives implied context for when to call the tool. However, it provides no explicit guidance about when to prefer this over sibling list_* tools or any exclusions.

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

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

The readOnlyHint annotation already signals safety, and the description's GET endpoint and 'List' verb are consistent with that. It adds that results include id, name, and path, but gives no further detail on pagination behavior or edge cases.

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

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

A single sentence conveys the purpose, resource scope, returned fields, and API endpoint with zero filler. Every word contributes to usability.

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

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

For a simple read-only list operation with fully documented parameters, the description is sufficient. It even names the fields returned in the absence of an output schema; only explicit sibling-comparison guidance is missing.

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

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

All five parameters already have descriptive schema comments, covering limit, offset, branchId, projectId, and directoryId. The description adds no new parameter meaning, so baseline 3 is appropriate since schema coverage is 100%.

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: 'List directories (folders) in a project', names the returned fields, and includes the exact API endpoint. This clearly distinguishes it from sibling tools like crowdin_list_files and crowdin_list_branches.

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

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

The description makes it clear this is for listing directories within a project, and the endpoint confirms scope. However, it does not explicitly mention when to choose this over sibling list tools or any exclusions.

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

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

Annotations already declare readOnlyHint=true, so the description does not need to repeat safety guarantees. The description adds a small amount of behavioral context by specifying the API endpoint and the fields returned, but it does not disclose additional nuances such as default pagination behavior or what 'status' 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 one concise sentence that front-loads the core action, resource, and field list. The API endpoint is a useful addition and nothing in the description is wasted.

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 read-only list operation, the description, schema, and annotations together cover the resource, key output fields, required parameter, and safety profile. It lacks only explicit guidance on when to choose this tool over similar sibling list tools.

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

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

Schema description coverage is 100%, and each parameter already has a clear description in the schema. The tool description adds only the projectId context through the API endpoint path, providing no meaningful semantic value 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 verb and resource: 'List source files in a project' and enumerates the returned fields (id, name, path, type, status). It is clear and unambiguous, though it does not explicitly differentiate itself from sibling list tools beyond the resource name being 'files'.

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

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

The description implies when to use this tool (whenever source files in a project are needed) and gives context by naming the project scope. However, it does not explicitly state when to prefer this over sibling tools like crowdin_list_directories or crowdin_list_strings, nor does it mention exclusions.

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

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

The readOnlyHint annotation already declares the operation safe, and the description reinforces it with the GET endpoint. It adds useful behavior beyond the annotation by stating the returned member attributes (id, username, role, permissions). No contradictions or hidden side effects are suggested.

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

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

Two short sentences deliver the purpose, output fields, and API mapping with no filler. The core action is front-loaded, and the API endpoint is a useful, non-redundant detail.

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, the description supplies the output fields, the schema documents all four parameters, and the annotation covers side-effect safety. No output schema exists, but the stated return fields are sufficient for an agent to understand the result shape.

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?

All four parameters have schema descriptions (100% coverage), so the schema carries the semantic load. The description only echoes projectId in the endpoint URL and does not add parameter-level meaning beyond the schema, matching the baseline for full schema coverage.

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

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

The description opens with a specific verb and resource ('List members of a project') and enumerates the returned fields, making the tool's purpose unambiguous. Since all sibling tools target different resources (files, branches, strings, etc.), the resource name 'members' cleanly distinguishes this tool without needing an explicit contrast.

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 context is clear: this is the tool to use when project membership details are needed, and no sibling tool covers members. It lacks an explicit when-not-to-use or alternative routing, but no competing tool exists in the sibling set, so the omission is not impactful.

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, so the safety profile is covered. The description adds useful context about token-scoped access and the underlying API endpoint, but it does not disclose pagination behavior or response shape beyond the listed fields.

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 concise sentences, front-loaded with the core action, followed by returned fields, usage guidance, and API reference. Every clause earns its place with no redundancy.

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

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

For a simple read-only list tool with no output schema, the description provides the action, access scope, returned fields, a concrete use case, and the canonical API endpoint. Combined with the fully documented schema, nothing essential is missing.

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

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

The input schema provides 100% parameter coverage with descriptions for limit, offset, groupId, and hasManagerAccess, so the description does not need to explain them. It adds no parameter-level detail, but the schema carries the burden effectively.

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

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

The description uses a specific verb and resource ('List projects'), states the access scope ('the token can access'), and lists the returned fields (id, name, sourceLanguageId, targetLanguageIds). This clearly distinguishes it from siblings like crowdin_get_project or crowdin_list_files.

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

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

It explicitly recommends the tool as a 'Good first call to discover project ids,' giving an agent clear context for when to invoke it. It does not name specific alternatives or exclusion criteria, so it stops short of a 5.

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

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

The readOnlyHint annotation already declares the operation is read-only, and the description adds the GET endpoint plus response fields. It does not disclose pagination behavior or response structure beyond the field names, which is a gap given the absence of an output schema.

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

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

Two short sentences achieve everything: the first states the action and key output fields, the second gives the API reference. No filler, no redundancy, effectively front-loaded.

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

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

With no output schema, the description helpfully names the returned fields. It also implicitly identifies the required projectId context and all optional filters are fully described in the schema. A minor omission is not stating explicit pagination semantics, but the schema's limit/offset descriptions cover that.

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

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

Schema description coverage is 100%, with each parameter including a clear description (e.g., limit 'Max rows (max 500, default 25)'). The description adds no parameter-level information beyond the schema, so the baseline score of 3 applies.

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

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

The description uses a specific verb 'List' with an unambiguous resource 'source strings in a project' and enumerates the returned fields (id, text, identifier, context). This clearly differentiates the tool from siblings like crowdin_list_files or crowdin_list_directories by 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?

The context is clear: it lists source strings in a project, and the resource name distinguishes it from add/translation/list siblings. However, it does not explicitly state when not to use it or name alternative tools, so it stops short of full routing guidance.

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

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

The readOnlyHint annotation already covers the safety profile, and the description reinforces it by noting this is a GET request and describing the output fields. It does not mention pagination behavior, but the schema documents limit/offset and their defaults.

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 convey the resource, return fields, and API endpoint with no filler. The most identifying information is front-loaded.

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

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

For a simple read-only listing tool with two optional pagination parameters and a full input schema, this description provides enough context: what is listed, which fields are returned, and how it maps to the API. The absence of an output schema is mitigated by the explicit field list.

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

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

Schema description coverage is 100%, with limit and offset already documented including defaults and bounds. The tool description adds no parameter-level meaning, 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 names a specific resource — Crowdin's catalog of supported languages — and states the API operation (GET /languages) plus the returned fields. This clearly distinguishes it from sibling list tools such as crowdin_list_branches or crowdin_get_language_progress.

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

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

It gives clear context that this is a reference catalog of all supported languages, so an agent can select it when it needs the static language list. It does not explicitly contrast it with crowdin_get_language_progress or state when not to use it, but the resource framing is unambiguous.

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

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

With readOnlyHint=true already covering the safety profile, the description adds the GET endpoint and expected fields (id, title, status, assignees), which helps the agent anticipate the read-only response. No destructive side effects are implied, and the description aligns with the annotation.

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

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

Two sentences with no filler: the purpose is front-loaded, the relevant fields are compactly listed, and the API endpoint provides concrete grounding. Every sentence earns its place.

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

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

For a simple read-only list operation, the description plus fully documented schema provide enough information to select and invoke the tool. The lack of an output schema is mitigated by the explicit field list, and pagination/filter parameters are fully described in the input schema.

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

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

The input schema has 100% description coverage, so all five parameters are already documented with types, constraints, and filters. The description adds no parameter-level detail beyond the schema, matching the baseline for fully covered schemas.

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

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

The description names a specific verb ('List'), a concrete resource ('translation/proofreading tasks'), a scope ('in a project'), and even the returned fields. This clearly distinguishes it from sibling tools such as crowdin_list_strings or crowdin_list_files.

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

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

The description provides clear context: this tool is for translation/proofreading tasks scoped to a project, which is distinct from the other list_* siblings. It does not explicitly name alternatives or exclusions, but the domain language is unambiguous enough for typical tool selection.

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