LingoHub MCP by usefulapi

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

Beyond the annotations, the description discloses the required permission, that the operation only adds a project, that existing data is unchanged, that it is non-idempotent in practice, and that it returns the new project with links. These are substantive behavioral details for a write 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 front-loaded with the write operation and permission need, then covers return value, mutation semantics, duplicate risk, and endpoint in compact sentences. Every sentence adds useful context 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?

For a create operation with strong annotations, full schema coverage, and no output schema, the description supplies the missing behavioral context: permission requirements, return information, additive-only semantics, and non-idempotent behavior. Nothing critical for correct invocation 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 all six parameters are already documented in the input schema. The description does not add parameter-specific meaning beyond tying workspace_url into the endpoint, 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: create a new localization project in a workspace. It clearly distinguishes the operation from read-oriented siblings such as list_projects and get_project.

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

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

It provides a clear usage prerequisite (settings-management permission) and warns that repeating the call can create a second project. However, it does not explicitly compare against alternatives like list_projects or get_project, so guidance is implied rather than fully specified.

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

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

Annotations already flag destructiveHint=true and idempotentHint=true, but the description adds genuinely new facts: the deletion cascades to text segment connections, and the operation is never automatically retried. Those are the details an agent needs before committing to an irreversible call, though permission requirements and error behavior remain 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?

Front-loaded with the most decision-relevant flags ('WRITE, DESTRUCTIVE'), followed by the concrete effect and then the endpoint. Very little waste, though the 'WRITE, DESTRUCTIVE' prefix partially duplicates annotation hints and the telegraphic phrasing is slightly clipped.

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 three-parameter delete with no output schema, the description covers the effect, cascade consequence, retry behavior, and target endpoint. Annotations carry the safety profile, so nothing critical is missing for correct invocation.

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

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

Schema description coverage is 100%, so all three parameters (workspace_url, project_url, image_id) are already fully documented including examples and sourcing hints. The description only surfaces image_id via the URL template and adds no format or validation 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?

States a specific verb and resource — 'delete one context image' — and adds the consequential scope detail that it also removes 'its connections to text segments'. The endpoint path confirms the object being deleted, so an agent can distinguish this from sibling lingohub_delete_resource at a glance.

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?

Usage is only implied: an agent infers it should call this to remove a context image, but the description never says when to prefer it over alternatives (e.g., delete_resource) or what prerequisites apply. The 'Never retried' note is behavioral, not usage routing.

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?

Goes well beyond the annotations by disclosing the cascade (target-language files and their translations are also destroyed), that the action is irreversible through the API, and that it is never retried. These are exactly the facts an agent needs before invoking a destructive call.

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?

Front-loaded with the WRITE, DESTRUCTIVE marker, then scope, then constraints, then the endpoint. Every sentence carries information an agent would otherwise have to guess.

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, no-output-schema tool, the description covers blast radius, irreversibility, retry policy, and the endpoint. Nothing essential to safe invocation 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 coverage is 100%, so the parameters are already fully documented, including that file_name is the SOURCE-language file. The description reinforces the source-file addressing constraint but adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('delete a resource container') and immediately expands the scope: the source-language file AND all its target-language files with translations. This is clearly distinguishable from siblings like lingohub_download_resource or lingohub_upload_resource_file.

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

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

Gives the key precondition that file_name and path must address the source-language file, which is the main way to misuse this call. It does not explicitly name an alternative (e.g. delete individual target files or replace via upload), so guidance is strong but not complete.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavior the annotations do not: silent truncation at 40000 characters with a truncated: true flag, plus the escape hatch via request_export. It does not mention auth or rate limits, but those are minor here.

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

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

Three tight sentences, front-loaded with the core action and scope, followed by the truncation caveat and the alternative. Every sentence carries information an agent needs to call the tool correctly.

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 download tool with 9 params all described in the schema and no output schema, the description covers the essential behaviors: scope, truncation, file/path distinction, and the full-copy alternative. The unmentioned optional params (branch, html_encoding, filters) are fully documented in the schema, so the remaining gap is minor.

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

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

Schema coverage is 100%, giving a baseline of 3, but the description adds real value by disambiguating file_name from path ("the folder goes in `path`"), which resolves a subtle interplay the schema only partly covers. No format detail on the remaining optional filters is added, but the schema handles those.

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 (Download), resource (one resource file), and scope (as text, in one language), and names the endpoint. It is clearly distinguishable from siblings like list_resources and request_export without opening any 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?

Routes the agent to request_export when a full, untruncated copy is needed, and clarifies that file_name comes from list_resources with the folder going in path. Lacks explicit guidance on when to prefer list_resources or upload_resource_file, but the primary alternative and its condition are stated.

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

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

Annotations already declare readOnly and non-destructive, so the bar is lower. The description adds genuine behavioral context: the status lifecycle values (NEW, SCHEDULED, PROCESSING, SUCCESS, SKIPPED, ERROR), that error details are surfaced, and that a pre-signed ZIP URL appears only when done — details not derivable from 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?

Efficient and front-loaded: the return content and status values lead, with the GET endpoint appended for reference. Slightly dense in a single sentence, but every clause carries information.

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

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

With no output schema, the description carries the return-shape burden and does so well by enumerating status values, error details, and the conditional download URL. A poll-cadence or timeout note would round it out, but nothing an agent needs to call it correctly 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% and all three parameters are fully documented in the schema. The description references export_id contextually but adds no format or syntactic detail beyond what the schema already provides, so baseline 3 applies.

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

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

States a specific verb+resource: retrieves status of an export started with request_export, enumerating the per-file statuses and the download URL returned. It clearly distinguishes itself from the sibling request_export by being the status-poll counterpart.

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?

Description ties usage to 'an export started with request_export', making the when-to-use obvious: after kicking off an export, poll this. It doesn't state exclusions or an explicit alternative, 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?

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true), so the description's job is to add context. It does so usefully by naming the resources returned — including the project_locales field name — and giving the HTTP route, which tells the agent this is a direct single-resource fetch with no filtering or pagination.

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: the payload contents first, the endpoint second. No filler, no redundancy with the title (which merely says 'Get project').

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 enumeration of returned fields is doing necessary work and largely covers the return contract; the endpoint path disambiguates from status/export tools. Minor gap: nothing on behavior for a missing or inaccessible project slug.

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 both parameters are documented with examples and a pointer back to list_projects as their source. The description adds nothing beyond naming project_url in the path template, so baseline 3 applies.

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

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

States a specific verb+resource ('One project') and enumerates exactly what a project contains (title, description, owner email, project_locales, timestamps, links), plus the REST endpoint. This clearly separates it from lingohub_list_projects, though it never names that sibling explicitly.

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

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

Usage is implied by 'One project' versus the plural list tool and by the required project_url/workspace_url pair, but there is no explicit 'use this when you have a slug from list_projects' statement or any exclusion. An agent can infer the case but must do the work itself.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds real value beyond that by disclosing the full response shape (segment status buckets, quality-check failures, export formats, Git connection state) and the underlying GET endpoint, which matters given there is no output schema. It says nothing about pagination, rate limits, or response size for large projects.

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

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

Two sentences, front-loaded with the core purpose followed by the payload inventory and the endpoint. Every clause carries information, though the trailing 'GET .../projects/{project_url}/status' is mildly redundant with the schema's project_url definition.

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 must characterize the return value, and it does so thoroughly enough for an agent to decide whether to call it. Parameters are fully covered by the schema, so the only shortfall is the absence of guidance on response size or paging for projects with many resource files.

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 workspace_url, project_url, and branch are all documented in the schema, including the branch default and the HTTP 422 on unknown branches. The description adds no parameter-level meaning beyond restating project_url in the endpoint path; 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 verb-resource pair ('Translation status of one project') and enumerates exactly what the payload contains: per-locale segment counts, failing quality checks, supported export formats, and Git connectivity. It implicitly separates itself from lingohub_get_project (metadata) and lingohub_get_workspace_status (workspace scope) via 'one project', but never names those siblings explicitly.

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

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

The scope ('one project', per-locale counts, quality checks, Git pushability) implies when an agent would want this over get_project or get_workspace_status, but there is no explicit when-to-use/when-not statement or named alternative. Usage must be inferred from the returned-data 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?

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds real value beyond that by enumerating the returned fields and status buckets, plus the underlying endpoint — though it says nothing about pagination or limits for large workspaces.

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 tightly packed elements: one sentence giving the resource and its returned fields, one line giving the path. Front-loaded and zero filler.

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

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

With one fully documented parameter and complete annotations, the only remaining burden was explaining return values, and the description does that by listing the per-locale status counts. Missing only scale/pagination guidance for workspaces with many projects.

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 single workspace_url parameter is fully documented in the schema (including the list_projects hint). The description adds no parameter-level detail, so 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?

Specific verb+resource: 'translation progress of every project in one workspace', followed by the exact fields returned. The 'every project in one workspace' scope implicitly distinguishes it from lingohub_get_project_status, but the sibling is not named explicitly, keeping it just below 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?

Usage is implied by the workspace-wide scope (use it when you need status across all projects), but there is no explicit when-to-use / when-not-to-use statement or named alternative such as lingohub_get_project_status for single-project queries.

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, destructiveHint=false, and openWorldHint=true. The description adds useful behavioral context beyond that: results are paginated, the page index is zero-based, and returned records include connected-segment counts and processing status. It does not discuss auth or rate limits, but the annotations already cover the safety 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 definition is front-loaded with the resource and return fields, followed by a compact pagination note and endpoint. Every sentence adds useful information without repetition or filler.

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

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

For a simple read-only list tool with full schema coverage and annotations, the description provides enough context to invoke it correctly. It mentions the return attributes and pagination, though it does not describe the full response shape or default page size. These gaps are minor because the schema covers pagination 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 100%, so all four parameters are already documented in the schema. The description reinforces that page is zero-based and that images belong to a project, but adds no new parameter semantics beyond what the schema provides. This fits the baseline of 3 when the schema does the heavy lifting.

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

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

The description states a specific verb and resource: list context images of a project. It also defines what context images are and mentions connected-segment counts and processing status. This clearly distinguishes it from sibling mutation tools such as delete_context_image and from resource-listing tools.

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

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

The description implies the tool is used to inspect a project's context images and pagination behavior is documented. However, it does not explicitly state when to use this tool versus alternatives or any exclusions. Usage is therefore implied rather than guided.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered; the description adds real value beyond them by disclosing visibility scope (owned and shared, across workspaces) and the contents of each returned entry. It does not mention ordering, size limits or pagination behavior for a potentially large cross-workspace listing.

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 scope statement comes first, then the payload contents, then the underlying endpoint. Every clause carries information an agent would otherwise have to infer.

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 correctly compensates by naming the fields each entry contains and why they matter. The only gap is behavioral scale information — whether the full cross-workspace list is returned at once or truncated — which matters for an 'every project' listing.

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 takes zero parameters, so the baseline is 4 and there is no parameter syntax the description could usefully add. The description instead documents the response fields (title, links, workspace_url and project_url slugs), which is appropriate for a no-arg tool.

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 (list) and resource (Lingohub projects) plus the exact scope: every project the API key can see, owned and shared, across workspaces. That scope phrasing implicitly separates it from the singular lingohub_get_project and the status siblings, so an agent can route correctly without opening a 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 sentence 'the workspace_url + project_url slugs that every other tool needs' makes clear this is the entry-point call that supplies identifiers to the rest of the toolset. It stops short of naming a specific alternative or an exclusion (e.g., when to use get_project instead), so it is strong context rather than full when/when-not guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds genuine value by naming the returned fields and the download link and by giving the endpoint path, but it says nothing about pagination, result limits, or ordering for a list 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?

A single tight sentence plus the endpoint, front-loaded with the resource and the returned fields. Nothing is wasted, though it is arguably too terse for a list tool.

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

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

No output schema exists, and the description partially compensates by listing the returned fields (name, locale, links). Combined with a fully documented input schema and clear read-only annotations, an agent has enough to call it correctly; only pagination/result-size behavior 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 all five parameters (including the branch default/422 behavior and the locale_in_file_name enum) are fully documented in the schema. The description adds no parameter semantics beyond embedding project_url in the endpoint path, 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?

States a specific verb (List) and resource (a project's resource files) and enumerates the returned fields, making it distinct from lingohub_list_projects and lingohub_list_context_images. It stops short of explicitly naming a sibling for differentiation, so a 4 rather than 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?

No indication of when to use this versus alternatives such as lingohub_get_project or lingohub_list_projects, and no stated prerequisites or exclusions. The agent must infer the calling context 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?

Annotations already declare destructiveHint=true, idempotentHint=false and readOnlyHint=false, so the safety profile is covered. The description adds genuinely new context beyond them: the existing-connection prerequisite, that it mutates the user's actual Git repo, and the 'Never retried' retry semantics.

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

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

Front-loaded with the 'WRITE:' marker, then purpose, prerequisite, and side effect in a tight sequence. The trailing POST path is somewhat redundant given the tool's naming but is minor overhead.

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 11-param destructive write tool with no output schema and strong annotations, the description covers purpose, prerequisite, mutation effect, and retry behavior. It does not describe what the response returns (commit SHA, PR URL), but no output schema exists so that gap is small.

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 11 params (path, branch, language, push_type, PR fields) are already documented in the schema. The description reinforces push_type branching but adds no format or default detail beyond what the schema states, 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?

Specific verb (push) + resource (resource files) + explicit destination (linked Git repository, naming the providers) and scope (project-level). No sibling does anything similar, so it is trivially distinguishable from the create/delete/list/download 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?

States a real prerequisite ('the connection must already exist') and explains how push_type selects commit-to-branch vs pull-request behavior. No sibling offers an alternative path to this action, so there is nothing meaningful to exclude, but there is also no explicit 'use when X' framing.

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?

Adds real context beyond the annotations: the operation is asynchronous, it 'changes no project data' (reconciling the readOnlyHint=false with a non-destructive outcome), and the result is an export id that must be polled. Minor gaps remain around job expiry or concurrent export limits, but the lifecycle is well 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?

Four tight sentences, front-loaded with the action, then the mutation profile, then the follow-up procedure, then the endpoint. No sentence is redundant and nothing is buried.

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 async job-creating tool with no output schema, the description supplies what an agent actually needs: the return value (export id), the polling target, and the success condition. The remaining parameter detail is fully covered by the 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?

Schema coverage is 100%, so the schema documents branch, languages, file_paths, project_url, workspace_url, and export_format on its own. The description adds one meaningful default ('Without filters it exports every file and language') but nothing about the filter interaction or format override.

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

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

States a specific verb and resource ('Start an asynchronous export of a project's resource files as a ZIP') and immediately clarifies the mechanism ('creates an export job'). It explicitly separates itself from the sibling get_export, which is the natural point of 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?

Gives the follow-up procedure explicitly ('poll get_export until its status is SUCCESS') and explains the default behavior when no filters are supplied. It stops short of contrasting with siblings like download_resource or list_resources, so the 'when not to use this' side is left implicit.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is known. The description adds genuinely useful context beyond that: the concrete consequence ('translations already in Lingohub can be overwritten or switched off') and the retry rule ('Never retried'), which is critical for a non-idempotent write. It stops short of describing the response or auth requirements.

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

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

Three tight sentences, front-loaded with the WRITE marker and the resource scope, then the language rule, then the risk/flag guidance. The trailing POST endpoint is mildly redundant given the structured schema but still orienting.

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 13-parameter destructive write with no output schema, the description covers what is mutated, how language is resolved, and retry semantics — the essentials. The remaining gap is that with no output schema it could say what the import returns (e.g., counts of created/updated/deactivated segments), leaving the agent unsure how to confirm success.

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

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

Schema coverage is 100%, so baseline is 3, and the description does add value by grouping the six import flags into a single semantic statement about changing versus deactivating segments, and by clarifying that language can come from the file name or the `language` field. It doesn't add detail on path/branch conflict handling beyond what the schema already documents.

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

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

States a specific verb and resource ('upload one text resource file') plus the accepted formats (JSON, properties, XLIFF, PO) and the target scope (into a project). It is clearly distinguishable from siblings like download_resource, delete_resource, and list_resources without opening any schema.

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

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

It gives real guidance on how to use the import flags ('state the flags you want') and explains the language-resolution precedence, but it never says when to choose this tool over alternatives such as push_to_repository, nor does it state prerequisites like required permissions or that the project must already exist.

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